# Manuel de &okteta;

## Introduction

&okteta; est un simple éditeur de fichiers de données brutes.

Les données sont affichées en deux versions : les valeurs numériques des octets et les caractères assignés à ces valeurs. Ces caractères et valeurs peuvent être affichés soit sur deux colonnes (l'affichage traditionnel des éditeurs hexadécimal) ou sous forme de ligne avec la valeur au-dessus du caractère. L'édition peux se faire simultanément pour les valeurs et pour les caractères.

À coté des possibilités d'édition communes, &okteta; apporte aussi quelques petits outils, comme le déchiffrage de liste de tables dans des types de données communs, un tableau listant tous les octets possibles avec leurs équivalent de caractères et valeurs, une vue d'informations avec un outil de statistique, de calculateur de somme de contrôle et un outil d'extraction de chaîne.

Toutes les modifications apportées aux données peuvent être annulées ou refaites.

## Les bases

### Démarrage de &okteta;

Saisissez ``okteta`` dans une invite de commande ou sélectionnez Éditeur hexadécimal depuis le groupe Applications Outils dans le lanceur d'applications.

Les lignes de commande &Qt; et &kde; standard sont disponibles, et peuvent être listées en saisissant ``okteta` `--help``.

Les options de ligne de commande spécifiques à &okteta; sont :

``<&URL;(s)>`` - ouvre un ou des fichiers depuis la ou les &URL;s spécifiées.

### Usage

La fenêtre principale de &okteta; contient les composants suivants : une barre de menu, une barre d'outils, une barre d'état, une ou plusieurs barres latérales avec des outils, et la vue principale avec les onglets des fichiers ouverts.

Quand un fichier est ouvert ou qu'une nouvelle table d'octets est créée, ces octets sont listés de façon consécutive par lignes avec un nombre donné d'octets par ligne. Celles-ci sont affichées sous deux formes différentes : comme valeurs numériques des octets et comme caractères assignés à ces valeurs. Ces valeurs et ces caractères peuvent être affichés soit séparés en deux colonnes soit côte à côte avec la valeur affichée au dessus du caractère. Sur le côté gauche, les décalages du premier octet de chaque ligne sont affichés.

Les traitements sont semblables à la plupart des éditeurs de texte : les données peuvent être éditées, coupées, copiées, glissées et déplacées. Un curseur affiche la position courante. Appuyer sur la touche Inser affiche soit le mode écrasement, soit le mode insertion. Le mode écrasement est plus strict que dans les éditeurs de texte, car il ne tolère pas de changement de la taille du tableau d'octets.

Mise à part le fait que le contenu d'un fichier est affiché sous deux formes différentes, une seule des deux formes est active pour la modification de données. Il y a deux curseurs en interaction : un pour la valeur et l'autre pour le caractère associé. Le curseur de la forme active clignote. Dans la partie caractère, les caractères sont saisis directement. Dans la partie valeur, la frappe d'un chiffre ouvrira un petit éditeur où seront rentré le reste de la valeur.

La boîte de dialogue de recherche permet à l'utilisateur de chercher une entrée spécifique d'octets, définit comme une valeur (hexadécimal, décimal, octal, binaire) ou texte (en encodage 8-bits ou en UTF-8).

Plusieurs tables d'octets peuvent être ouvertes en même temps mais une seule peut être active. Utilisez le menu Affichage pour sélectionner quelle table d'octets sera active.

## Outils

### Aperçu

&okteta; contient des outils qui servent à analyser et modifier des tables d'octets et d'autres plus généraux. Ces outils peuvent être activés ou désactivés depuis le menu Outils. Chaque outil apparaît dans une petite vue et l'onglet relatif à cette outil est placé soit. Chaque outil sélectionné possède un petit affichage soit sous forme d'onglet dans la fenêtre principale, soit sous forme de fenêtre flottante indépendante. La modification de la disposition des outils se fait avec la souris en pressant le &BGS; sur la bar de titre d'une fenêtre d'outil, déplacer celle-ci à l'endroit souhaité et relâcher le &BGS; pour terminer le déplacement, d'autre part vous pouvez revenir à la position de en pressant la touche &Echap;.

#### Analyseurs et opérateurs

Table d'octets

- La table liste toutes les valeurs d'octets possibles, aussi bien en valeurs de caractère qu'en valeur numérique.

  La valeur sélectionnée peut être insérée à la position du curseur pour un nombre défini d'octets, en utilisant le bouton Insérer ou en faisant un double-clic sur la ligne de la table.

Filtre binaire

- Le filtre exécute des opérations binaires sur des octets sélectionnés. Après avoir choisi l'opération (AND, OR, ROTATE), les paramètres, le cas échéant, peuvent être définis dans la boîte de dialogue ci-dessous. Le filtre est exécuté en utilisant le bouton Filtrer.

Chaînes

- Cet outil localise des chaînes dans les octets sélectionnés. Après avoir choisi la longueur minimale de la chaîne, les chaînes sont recherchées en utilisant le bouton Extraire. La liste des chaînes affichées peut être restreinte en saisissant un terme dans le filtre.

Statistiques

- Cet outil crée une statistique pour les octets sélectionnés. La statistique donne la fréquence de l'occurrence de chaque valeur d'octet dans la sélection. Les informations peuvent être calculées en utilisant le bouton Construire.

Somme de contrôle

- Cet outil calcule les différentes sommes de contrôle ou sommes de hachage des octets sélectionnés. Après avoir choisi l'algorithme et sélectionné les paramètres, s'il y en a, la somme est calculée en utilisant le bouton Calculer.

Table de décodage

- La table affiche les valeurs de l'octet ou des octets à partir du curseur, pour des raisons d'utilisation de types de données communs, comme un entier ou un réel, mais aussi UTF-8. Un double clic sur une ligne dans la table d'octet ouvre un éditeur, dont la valeur peut être éditée et changée.

Structures

- Cet outil permet d'examiner et de modifier des tables d'octets à partir des définitions de structures créées par l'utilisateur. Les instructions détaillées sont dans une sectionparticulière.

#### Outils généraux

Système de fichiers

- Cet outil inclut un navigateur de fichier qui peux être utilisé pour ouvrir des fichiers.

Documents

- Cet outil affiche l'ensemble des fichiers actuellement créés ou chargés. Des symboles marquent le fichier dans l'affichage actuellement actif mais aussi les modifications non-enregistrées ou quelle copie a été modifiée par un autre programme.

Signets

- Cet outil est utilisé pour organiser les signets autrement qu'avec le menu Signets.

  Les signets ne sont actuellement que temporaires et donc, non enregistrés, si vous fermez une table d'octets ou le programme principal.

Info fichier

- Cet outil affiche des informations sur le fichier courant, incluant son type, son emplacement de stockage et sa taille.

### Outils de structure

#### Général

L'outil « Structures » permet d'analyser et de modifier des tables d'octets à partir de définitions de structure créée par l'utilisateur. Celles-ci peuvent être créées à partir de tableau, d'unions, de types basiques et de valeurs énumérées.

Il possède une configuration propre, disponible avec le bouton Paramètres. Différentes options peuvent être configurés, comme le type (décimal, hexadécimal ou binaire) et dont les valeurs sont affichées. De plus, il est possible de choisir quelles définitions de structure sont utilisées et quelle structure est utilisée dans la fenêtre.

Les Structures sont définies dans &okteta; fichier de définition de structures (reposant sur &XML;, les fichier avec l'extension `.osd`). De plus, un fichier `.desktop` contient les métadonnées sur ce fichier de description de structure, somme l'auteur, la page d'accueil et la licence.

Actuellement il n'y a pas d'outil intégré pour la création et modifier les définitions de structure, donc cela est fait manuellement comme décrit à la section suivante.

#### Installer les définitions de structures

##### Installation utilisant KNewStuff

La façon la plus simple d'installer une nouvelle définition de structure est d'utiliser l'outil intégré KNewStuff d'&okteta;. Pour installer une structure existante, ouvrer les paramètres de configuration de l'outil Structures. Sélectionner l'onglet Gestion de structures et cliquer sur Obtenir de nouvelles structures. Une fenêtre s'ouvre et vous permet d'installer ou de désinstaller des structures.

##### Installation des définitions de structure manuellement

L'outil Structure utilise les descriptions de structure dans le sous-dossier `share/apps/okteta/structures/` du dossier utilisateur pour les données de programme (accessible en exécutant ``kde4-config``--localprefix``). Vous pourrez avoir besoin de créer ce dossier si aucune définition de structures n'est installé.

Chaque définition de structures se composent de deux fichiers : le premier fichier pour la définition actuelle et le second fichier `.desktop` pour les métadonnées (auteur, version, etc.).

Dans ce dossier, il y a un sous-dossier propre à chaque définition de structure. Il contient le fichier `.desktop` et le fichier `.osd` ou le fichier `main.js` de cette définition.

Par exemple, avec l'explorateur de données de `.kde` et une définition de structure appelée Structure-Exemple il y a un dossier `.kde/share/apps/okteta/structure/Structure-Exemple`, qui contient un fichier `Structure-Exemple.desktop` et un fichier `Structure-Exemple.osd`.

##### Utilisation des nouvelles structures installées

Après avoir installer une nouvelle définition de structure, vous avez besoin de redémarrer &okteta; avant de pouvoir l'utiliser. Après avoir lancer &okteta;, ouvrer les paramètres de l'outil Structure. Sélectionner alors l'onglet latéral Gestion des structures et vérifier que les cases relatives aux définitions de structure voulu sont cochées. Puis, aller dans l'onglet latéral Structures et vérifier que les structures voulu sont dans le panneau de droite.

#### Partage des définitions de structure

Pour les structures plus communes, il est recommandé de ne pas créer une définition pas vous-même, mais plutôt de réutiliser une définition existante comme à l'adresse suivante kde-files.org.

Vous pouvez aussi partager une définition propre. Pour cela, créer une archive (&pex; une archive compressé en tar, `.tar.gz`) qui contient seulement le sous-dossier avec le fichier `.desktop` et le fichier de définition de structure. Avec l'exemple de la section précédente, nous aurions le dossier `Structure-Exemple` avec son contenu. Utiliser ce format pour le partage de définitions de structure permet leurs installation directement dans &okteta; et ne requiert aucune installation manuelle.

#### Créations de définitions de structure

La création de structures peut se faire de deux manières différentes, la première par écriture de la définition en &XML; et la seconde par utilisation de JavaScript. L'approche avec JavaScript vous permet de créer des structures plus complexes avec des fonctionnalités comme, par exemple, la validation de la structure. L'utilisation de &XML; vous offre moins de fonctionnalités mais, si une structure statique est la seule chose dont vous avez besoin, cela peut être plus facile. Si vous avez besoin d'une structure dynamique, par exemple, où les longueurs des tables dépendent d'autres valeurs dans la structure ou si la disposition de la structure est différente quand certaines de ses valeurs sont modifiées, alors, vous devrez écrire la définition de la structure en JavaScript. Il y a une exception à cette règle : si vous avez une table où la longueur est supposée être exactement la même qu'une autre valeur de la structure, alors, vous pouvez utiliser &XML;. Mais, s'il y a quelque chose comme longueur - 1, alors, vous devez utiliser JavaScript.

#### Format de fichier &XML; pour la définition de structures

Le fichier &XML; avec l'extension `.osd` ne possède qu'un élément racine : <données> sans aucun attribut. Dans cet élément, il doit y avoir un des éléments suivants :

<primaire>

- Pour créer des types primaires de données, comme, par exemple, int et float. Cet élément n'accepte aucun sous-élément et peut avoir les attributs suivants :

  type

- Le type de ce type primaire. Il doit être parmi les suivants :

  - char pour un caractère ASCII sur 8 bits

  - int8, int16, int32, int64 pour un entier signé de cette taille

  - Uint8, Uint16, Uint32, Uint64 pour un entier non signé de cette taille

  - bool8, bool16, bool32, bool64 pour un booléen non signé (0 = faux, tout autre valeur = vrai) de cette taille

  - float pour un nombre à virgule flottante au format IEEE754 sur 32 bits

  - double pour un nombre à virgule flottante au format IEEE754

<bitfield>

- Créer un « bitfield ». Cet élément n'accepte aucun sous-élément et peut avoir les attributs suivants :

  largeur

- Le nombre de bits utilisés par ce « bitfield ». Doit être entre 1 et 64.

type

- Le type de ce « bitfield ». Doit être l'un de suivants :

  - unsigned pour un « bitfield » où la valeur sera interprétée comme une valeur non signée (plage de valeurs de 0 à 2 largeur - 1)

  - signed pour un « bitfield » où la valeur sera interprétée comme une valeur signée (plage de valeurs de -2 largeur - 1 à 2 largeur - 1 - 1)

  - bool pour un « bitfield » où la valeur sera interprétée comme un booléen.

  Rappelez vous de toujours ajouter du remplissage après un <bitfield>, car sinon, le prochain élément (sauf les chaînes et les tables qui ajoutent automatiquement le remplissage) démarrera au milieu d'un octet. Bien évidemment, le remplissage n'est pas nécessaire si vous recherchez cette situation.

<enum>

- Pour créer un type primaire mais où les leurs sont affichées comme membre d'une énumération si possible. Cet élément n'accepte aucun sous-élément (cependant, vous aurez besoin d'un attribut <enumDef> dans le fichier pour le référencer). Il possède les attributs suivants :

  enum

- Le type « enum » sous-jacent pour cette valeur. Doit correspondre à l'attribut de nom de l'un des attributs <enumDef> de ce fichier.

type

- Le type pour « enum ». Veuillez regarder l'attribut de type de <primitive>. La seule différence est que Double et Float n'ont aucun sens.

<flags>

- Ceci est similaire à <enum> avec une seule différence que les valeurs sont représentées comme un ou bit-à-bit de toutes les valeurs de l'énumération.

<struct>

- Pour créer une structure. Tous les autres éléments (incluant <struct>) peuvent être ses fils et feront alors partie de la structure résultat.

<union>

- Créer une union. Fondamentalement identique à <struct> sauf que tous les éléments fils commenceront à partir du même décalage. Utile pour interpréter la même suite d'octets de différentes façons.

<array>

- Pour créer une table. Cet élément n'accepte qu'un seul fils (le type sous-jacent de la table), qui peut être n'importe lequel des éléments, même <array> lui-même. Il possède aussi les attributs suivants :

  longueur

- Le nombre des éléments dans cette table comme nombre décimal. Alternativement, il peut être aussi une chaîne qui correspond à l'attribut de nom d'un élément précédemment défini <primaire>, <enum> ou <flags>. Ainsi, la longueur sera la valeur de cet élément. Actuellement, elle est limitée à 10 000 car des tables plus grandes utiliseraient trop de mémoire et ralentiraient trop l'outil.

<string>

- Pour créer une chaîne avec des encodages divers. Par défaut, vous obtenez une chaîne de style C, terminée par NULL. Cependant, différents types de chaînes peuvent être créées avec les attributs suivants :

  Terminé-par

- Cet attribut détermine quel est le caractère unicode terminant la chaîne. Il doit être un nombre en hexadécimal (optionnellement commençant par 0x). Quand l'encodage est en ASCII, seules les valeurs supérieures à 0x7f sont significatives. Si ce n'est pas le cas et si ne sont définis ni maxCharCount ni maxByteCount, la valeur 0 est prise par défaut (chaîne de type C).

maxCharCount

- Le nombre maximum de caractères que peut avoir la chaîne. Si le paramètre terminé-par est aussi défini, alors, quel que soit le caractère atteint d'abord, la chaîne se termine. Ceci est mutuellement exclusif avec maxByteCount

maxByteCount

- Le nombre maximum d'octets de la chaîne peut être important. Si le paramètre terminé-par est aussi défini, quel que soit le caractère rencontré d'abord, la chaîne se termine. Ceci est mutuellement exclusif avec maxCharCount. Avec des encodages comme ASCII, cela est similaire à maxCharCount.

type

- L'encodage de la chaîne. Peut être l'un des suivants :

  - ASCII

  - LATIN-1

  - UTF-8

  - UTF-16-LE ou UTF-16-BE. Si, le suffixe fourni n'est ni-LE ni -BE, le mode « little indian » est pris par défaut.

  - UTF-32-LE ou UTF-32-BE. Si, le suffixe fourni n'est ni-LE ni -BE, le mode « little indian » est pris par défaut.

Chaque élément accepte aussi un nom d'attribut qui est alors visible dans l'affichage de structures.

#### Un exemple de définition de structures, à la fois en &XML; et en JavaScript

##### Les étapes communes à ces deux méthodes.

Les métadonnées doivent ressembler à ceci :

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

            Name= Test simple de structure
            Comment=Une structure de test très simple ne contenant que deux éléments

            X-KDE-PluginInfo-Author=Alex Richardson
            X-KDE-PluginInfo-Email=foo.bar@email.org
            X-KDE-PluginInfo-Name=simplestruct
            X-KDE-PluginInfo-Version=1.0
            X-KDE-PluginInfo-Website=http://www.plugin.org/
            X-KDE-PluginInfo-Category=structure
            X-KDE-PluginInfo-License=LGPL
            X-KDE-PluginInfo-EnabledByDefault=false

- L'icône affichée dans &okteta; pour cette structure peut être n'importe quoi retourné en exécutant ``kdialog``--geticon`` ou un emplacement vers une icône

. Ces champs doivent être assez explicites, sauf pour `X-KDE-PluginInfo-Name`. La valeur de ce champ doit correspondre au nom du dossier contenant le fichier, tout comme le nom du fichier `.desktop`. Pour la création des définitions de structures en &XML;, le nom du fichier `.osd` doit aussi correspondre au nom de la structure.

Cet exemple montre un dossier nommé `simplestruct` contenant le fichier `simplestruct.desktop`. Lors de la définition de structures en &XML;, le dossier doit aussi contenir un fichier nommé `simplestruct.osd`. En utilisant JavaScript, un fichier nommé `main.js` existe à la place.

##### Une définition de structure simple &XML;

Pour commencer, une structure de test très simple sera définie, contenant uniquement de tous les types de données (un caractère, un entier signé 32 bits et un « bitfield »). Cela s'exprime en langage C / C++ comme

    struct simple {
                char a-Car ;
                int a-Ent ;
                bool bit-zone : 1 ;
                unsigned remplissage : 7 ;
              } ;

La première étape est d'écrire le fichier `.osd` conformément au format de fichier défini dans la section précédente. Il peut être appelé `simplestruct.osd` :

              <?xml version="1.0" encoding="UTF-8"?>
              <data>
                <struct name= « simple » >
                  <primitive name= « a-Car » type= « Char » />
                  <primitive name= « a-Ent » type= « Int32 » />
                  <bitfield name= « bit-zone » type= « bool »width= « 1 » />
                  <bitfield name= « remplissage » type= « unsigned » width= « 7 »/>
                </struct>
              </data>

ce qui est clairement similaire à une définition en langage C / C++.

Maintenant, créez un dossier `simplestruct` dans le dossier d'installation de structures (veuillez regarder l'installation manuelle de définitions de structures) et copiez les deux fichiers dans ce dossier. Maintenant, vous pouvez re-démarrer &okteta; et utiliser la nouvelle structure.

##### La structure simple en JavaScript

Pour définir la structure ci-dessus en JavaScript, créez un fichier nommé `main.js` à la place de `simplestruct.osd`. Le contenu de ce fichier doit être :

            function init() {
              var structure = struct({
                a-Car : char(),
                a-Ent : int32(),
                bit-zone : bitfield( « bool », 1),
                remplissage : bitfield( « unsigned », 7),
              })
              return structure;
            }

La structure affichée par &okteta; est toujours la valeur retournée par la fonction `init`.

Les fonctions suivantes peuvent être appelées pour créer un type primaire :

- char()

- int8(), int16(), int32() ou int64()

- Uint8(), Uint16(), Uint32() ou Uint64()

- bool8(), bool16(), bool32() ou bool64()

- float()

- double()

La fonction bitfield possède deux paramètres, le premier de type chaîne comprenant `bool`, `signed` ou `unsigned`. Le second paramètre est un entier qui définit la largeur en bits.

##### Structures plus complexes

Ensuite, une structure plus complexe est définie et enregistrée dans un fichier nommé `complexe.osd`. Elle contiendra deux tables (une avec une longueur fixe et l'autre où la longueur est déterminée durant l'exécution), aussi bien qu'une structure imbriquée et une union

              <?xml version="1.0" encoding="UTF-8"?>
              <data>
                <struct name="complexe">
                  <primitive name="size" type="Uint8" />
                  <union name="aUnion">
                    <array name="Quatre-Octets" length="4">
                      <primitive type="Int8" />
                    </array>
                  </union>
                  <struct name="imbrication">
                    <array name="string" length="size"> < ! -- fait référence la taille du champ ci-dessus -->
                      <primitive type="Char" />
                    </array>
                  </struct>
                </struct>
              </data>

Ceci devrait correspondre à la déclaration suivante en pseudo-C / C++

    struct complexe {
                Uint8_t size ;
                union aUnion {
                  int8_t Quatre-Octets[4] ;
                } ;
                struct imbrication {
                  char string[size] //non valable en C++, valeur de référence de la taille Uint8
                } ;
              } ;

Vous pouvez bien évidemment n'avoir que des champs de référence à des tables de longueur dynamique avec la table.

Ensuite, le fichier `complexe.desktop` est créé, comme dans l'exemple précédent (veuillez vous assurer que vous avez défini correctement `X-KDE-PluginInfo-Name`). Faites aussi de même pour installer l'ensemble des fichiers.

##### Plus d'informations

Quelques exemples de définitions de structures peuvent être trouvés ici. Ceci comprend, par exemple, l'en-tête de fichier pour les fichiers « PNG » et l'en-tête de fichier « ELF ». Un schéma &XML; décrivant la structure du fichier `.osd` peut être trouvé ici. Si vous avez besoin de plus d'informations, n'hésitez pas à contacter &Alex.Richardson.email;.

## Entrées de menu

Remarquez que la plupart des commandes de menu ont aussi un raccourci clavier.

### Menu de fichiers

&Ctrl;N Fichier Nouveau

- Crée un nouveau tableau d'octets...

  - Vide : comme un vide.

  - A partir du presse-papiers: avec le contenu courant du presse-papiers.

  - Motif...: avec un motif donné.

  - Données aléatoires...: avec des données aléatoires.

  - Séquence: avec tous les octets de 0 à 255.

&Ctrl;O Fichier Ouvrir...

- Ouvrir un fichier existant.

Fichier Récemment ouvert(s)

- Choisit un fichier parmi ceux récemment ouverts.

&Ctrl;S Fichier Enregistrer

- Enregistre le tableau d'octets dans un fichier associé.

Fichier Enregistrer sous...

- Enregistre le tableau d'octets dans un autre fichier avec un nouveau nom.

Fichier Exporter

- Exporte les octets sélectionnés dans un fichier...

  - Valeurs : encodage en octets.

  - Texte simple : encodage en caractères.

  - Base64: encodé dans un format « Base64 ».

  - tableau C : définition en tant que tableau de langage de programmation C.

  - Affichage en texte simple : comme dans la vue des données avec le numéro de ligne, les valeurs en octets et les caractères.

F5 Fichier Recharger

- Ignore tous les changements et recharge le tableau d'octets à partir du fichier.

&Ctrl;P Fichier Imprimer...

- Imprime le tableau d'octets actuel.

Fichier Permissions

- Modifier les privilèges de modification :

  Définir en lecture seule

- Lorsque ceci est actif, il n'est normalement pas possible de modifier le tableau d'octets chargé.

&Ctrl;W Fichier Fermer

- Ferme le tableau d'octets actuel.

Fichier Tout fermer

- Fermer tous les tableaux d'octets.

Fichier Fermer tous les autres

- Fermer tous en plus du tableau d'octets actuel.

&Ctrl;Q Fichier Quitter

- Fermer la fenêtre &okteta;.

### Menu de modifications

Actuellement dans &kde; 4.4, le simple copier / couper stocke les données dans le presse-papiers avec le type MIME « application / octetstream ». &klipper; n'est pas capable d'afficher ces données. Et quasiment toutes les autres applications ne peuvent pas non plus gérer ceci, car il ne s'agit tout simplement que de données brutes. Veuillez aussi consulter le sous-menu Copier comme.

&Ctrl;Z Édition Annuler

- Annule la dernière action.

&Ctrl;&Maj;Z Édition Refaire

- Refait la dernière action annulée.

&Ctrl;X Édition Couper

- Supprime les octets sélectionnés et les copie dans le presse-papiers.

&Ctrl;C Édition Copier

- Copie les octets sélectionnés dans le presse-papiers.

&Ctrl;V Édition Coller

- Insère les octets coupés ou copiés dans le presse-papiers.

Édition Copier comme

- Copie les octets sélectionnés dans le presse-papiers...

  - Valeurs : encodage en octets.

  - Texte simple : encodage en caractères.

  - Base64: encodé dans un format « Base64 ».

  - tableau C : définition en tant que tableau de langage de programmation C.

  - Affichage en texte simple : comme dans la vue des données avec le numéro de ligne, les valeurs en octets et les caractères.

Édition Insérer

- Insérer un motif...

- Insère la chaîne d'octets spécifiée à l'emplacement du curseur.

  Les options de cette boîte de dialogue vous permettent de spécifier le nombre d'insertions du motif ainsi que son format (Hexadécimal, Décimal, Octal, Binaire ou Caractère(s) ou UTF-8).

&Ctrl;A Édition Tout sélectionner

- Sélectionne le tableau d'octets en entier.

&Ctrl;&Maj;A Édition Désélectionner

- Désélectionne la sélection courante.

&Ctrl;E Modifier Sélectionner la plage...

- Ouvre une boîte de dialogue intégrée pour saisir la plage à sélectionner.

Ins Édition Mode écrasement

- Bascule entre le mode insertion et le mode écrasement.

  Le mode écrasement est mis en œuvre de manière très stricte, il n'est pas possible de modifier la taille des données (pas d'ajout ou de suppression d'octets).

&Ctrl;F Édition Chercher...

- Cherche un motif spécifié par vous dans le document. Il est possible de chercher des motifs de type hexadécimal, décimal, octal, binaire ou texte.

  Les options de cette boîte de dialogue vous permettent de spécifier le point de départ, la direction et la plage de recherche.

F3 Édition Poursuivre la recherche

- Cherche l'occurrence suivante du motif recherché par Chercher.

  Si aucun motif n'est spécifié, la boîte de dialogue sera affichée.

&Maj;F3 Édition Chercher en arrière

- Cherche l'occurrence précédente du motif recherché par Chercher.

  Si aucun motif n'est spécifié, la boîte de dialogue sera affichée.

&Ctrl;R Édition Remplacer...

- Remplace le motif recherché par un autre motif.

&Ctrl;G Édition Aller à l'offset...

- Déplace le curseur à la ligne spécifiée.

### Menu d'affichage

&Ctrl;+ Affichage Zoom avant

- Augmente la taille de la police de caractères.

&Ctrl;- Affichage Zoom arrière

- Diminue la taille de la police de caractères.

Affichage Afficher les caractères non imprimables

- Active ou désactive l'affichage des caractères non imprimables. Si l'affichage est désactivé, un caractère de substitution est affiché aux places correspondantes dans la colonne caractères.

F11 Affichage Afficher l'offset des lignes

- Active ou désactive l'affichage de l'offset sur un panneau à gauche.

Affichage Afficher des valeurs ou des caractères

- Sélectionne quelles interprétations des octets sont affichées. Les valeurs possibles sont :

  - Valeurs

  - Caractères

  - Valeurs et caractères

Affichage Encodage des valeurs

- Sélectionne l'encodage des valeurs, parmi :

  - Hexadécimal

  - Décimal

  - Octal

  - Binaire

Affichage Encodage des caractères

- Sélectionne l'encodage des caractères, à partir du sous-menu.

Afficher Disposition dynamique

- Définit les règles pour la disposition de l'affichage des données. Ceci définit combien d'octets sont affichés par ligne, en fonction de la largeur de l'affichage. Les règles possibles sont :

  - Aucun redimensionnement : la disposition est fixée selon le nombre actuel d'octets par ligne et n'est pas adaptée à une modification de la taille de l'affichage.

  - Ne regrouper que les groupes complets : place autant d'octets que possible par ligne, tant que les groupes d'octets sont complets.

  - Actif: similaire au précédent mais permet aussi les groupes incomplets d'octets.

Affichage Mode d'affichage

- Sélectionne la disposition de l'affichage, parmi :

  - Colonnes : les interprétations en valeurs et caractères sont affichées en disposition classique, chacune dans une colonne séparée.

  - Lignes : l'interprétation en caractères d'un octet est directement affichée sous l'interprétation en valeurs.

&Ctrl;&Maj;T Afficher Scinder Horizontalement

- Scinder la zone d'affichage avec l'affichage actuellement sélectionné en deux parties et ajouter une copie de l'affichage courant à la nouvelle zone sur le bas.

&Ctrl;&Maj;L Afficher Scinder Verticalement

- Scinder la zone d'affichage avec l'affichage actuellement sélectionné en deux parties et ajouter une copie de l'affichage courant à la nouvelle zone sur la droite.

&Ctrl;&Maj;R Afficher Fermer la zone d'affichage

- Fermer la zone d'affichage avec l'affichage actuellement sélectionné.

Afficher Afficher le profil

- La configuration d'affichage peut être enregistrée séparément des profils d'affichage. Le profil actuellement sélectionné peut être mis à jour directement à partir de la configuration actuelle d'affichage ou un nouveau profil peut être créé à partir de ceux-ci. Tous les profils d'affichage peuvent être gérés grâce à une boîte de dialogue disponible à partir de Configuration Gérer les profils d'affichage....

### Menu des fenêtres

Fournit une liste des vues actuelles. La fenêtre active est sélectionnée.

### Menu des signets

Plusieurs signets peuvent être positionnés pour un seul tableau d'octets. Chaque tableau d'octets a son propre ensemble de signets, et l'ensemble approprié est affiché en bas du menu Signets. Choisissez un signet à partir du menu pour déplacer le curseur et la vue sur celui-ci.

Les signets ne sont actuellement que temporaires et donc, non enregistrés, si vous fermez une table d'octets ou le programme principal.

&Ctrl;B Signets Ajouter un signet

- Ajoute un signet pour l'emplacement dans le tableau d'octets.

&Ctrl;&Maj;B Signets Supprimer le signet

- Supprime le signet courant. Cette commande n'est disponible que si le curseur est à un emplacement associé à un signet.

Signets Supprimer tous les signets

- Vide la liste des signets.

&Alt;Haut Signets Aller au signet précédent

- Déplace le curseur au signet précédent.

&Alt;Bas Signets Aller au signet suivant

- Déplace le curseur au signet suivant.

### Menu des outils

Fournit une liste des outils installés. Active ou désactive l'affichage de chacun des outils. Une description détaillée de chacun des outils est disponible dans la section Outils.

### Menu de configuration

Configuration Configurer les profils d'affichage

- Ouvre une boîte de dialogue pour créer, modifier, supprimer et définir un profil d'affichage par défaut.

Configuration Afficher la barre d'outils

- Active ou désactive l'affichage de la barre d'outils située sous la barre de menus.

Configuration Afficher la barre d'état

- Active ou désactive l'affichage de la barre d'état.

&Ctrl;&Maj;F Configuration Mode Plein écran

- Active ou désactive le mode plein écran.

Configuration Configurer les raccourcis clavier...

- Modifie les raccourcis clavier pour les actions.

Configuration Configurer les barres d'outils...

- Contrôle le contenu de la barre d'outils.

### Menu d'aide

&help.menu.documentation;

### Barre d'outils

La barre d'outils contient les icônes associées aux commandes suivantes :

(Toutes se comportent à l'identique de celles situées dans le menu)

- Nouveau

- Ouvrir

- Enregistrer

- Enregistrer sous

- Annuler

- Refaire

- Couper

- Copier

- Coller

- Chercher

- Chercher le suivant

## Remerciements et licence

&okteta;

Copyright du programme 2006-2012 par &Friedrich.Kossebau; &Friedrich.Kossebau.email;

Copyright de la documentation 2008, 2010 par &Friedrich.Kossebau; &Friedrich.Kossebau.email;, &Alex.Richardson; &Alex.Richardson.email;

Traduction française par &XavierBesnard;, &StanislasZeller;, &JeanJacquesFinazzi; et Hervé Boulogne herve.boulogne@gmail.com.

&underFDL; &underGPL;

## Installation

### Comment obtenir &okteta;

&install.intro.documentation;

### Compilation et installation

&install.compile.documentation;
&documentation.index;