# Het handboek van &okteta;

## Introductie

&okteta; is een eenvoudige bewerker voor de ruwe gegevens van bestanden.

De gegevens worden weergegeven in twee varianten: als de numerieke waarde van de bytes en als het teken dat behoort bij de waarden. Waarden en tekens kunnen getoond worden in twee kolommen (de traditionele weergave in hex-editors) of in rijen met de waarde boven het teken. Bewerken kan gedaan worden zowel in de waarden als in de tekens.

Naast de gebruikelijke bewerkingsmogelijkheden, biedt &okteta; ook een kleine set hulpmiddelen, zoals een tabel die decoderingen laat zien in algemene eenvoudige typen gegevens, een tabel die alle mogelijke bytes laat zien met zijn teken en overeenkomende waarden, statistische informatie, een rekenmachine voor een controlesom, een filter en een hulpmiddel voor extractie van tekenreeksen.

Alle wijzigingen aan de geladen gegevens kunnen eindeloos teruggezet of opnieuw gedaan worden.

## Grondbeginselen

### &okteta; opstarten

Type ``okteta`` op een commandoprompt of selecteer Hexbewerker uit de groep Toepassingen Hulpmiddelen in het toepassingenstartpaneel.

De standaard &Qt; en &kde; commandoregelopties zijn beschikbaar en kunnen worden getoond door ``okteta` `--help`` in te voeren.

Commandoregelopties specifiek voor &okteta; zijn:

``<&URL;('s)>`` - open bestand(en) uit de gespecificeerde &URL;('s)

### Gebruik

Het hoofdvenster van &okteta; heeft de volgende componenten: een menubalk, een werkbalk, een statusbalk, één of meer zijbalken met hulpmiddelen en het hoofddeelvenster met de tabbladen met gegevensweergaven.

Wanneer een bestand is geopend of een nieuwe reeks bytes wordt aangemaakt, dan worden de bytes, die er in zitten, achtereenvolgend getoond in regels met een gegeven aantal bytes per regel. Ze worden getoond in twee varianten: als de numerieke waarde van de bytes en als het teken toegekend aan de waarde. Waarden en tekens kunnen gescheiden van elkaar worden getoond in twee kolommen of bij elkaar met de waarde boven het teken. Aan de linkerzijde staan de offsets van het eerste byte in elke regel.

De behandeling is vergelijkbaar met die in de meeste tekstbewerkers: de gegevens kunnen bewerkt worden, geknipt, gekopieerd, geplakt, versleept en losgelaten zoals dat met tekst kan. Een cursor markeert de huidige positie. Op de Insert-toets drukken schakelt tussen de modi overschrijven en invoegen. De modus overschrijven is strikter dan in tekstbewerkers, omdat het geen bewerking toestaat die de lengte van de reeks bytes wijzigt.

Anders dan in tekstbewerkers wordt de inhoud in twee varianten getoond. Alleen een hiervan is actief met betrekking tot nieuwe invoer. Er worden twee gekoppelde cursors getoond voor de waarde en het tonen van het teken, de cursor van de actieve knippert. Met de tekens actief, kunnen tekens ingevoerd worden zoals bekend uit tekstbewerkers. Met de waarden actief opent het typen van een cijfer een minimale editor om de rest van de waarde in te voeren.

De zoekdialoog stelt de gebruiker in staat om naar een specifieke reeks byteste zoeken, te definiëren als waarden (hexadecimaal, decimaal, octaal, binair) of tekst (huidige 8-bit codering of UTF-8).

Meerdere byte-arrays kunnen tegelijk open zijn, maar slechts één kan er actief zijn. Gebruik het menu Venster om te selecteren welk byte-array actief zal zijn.

## Hulpmiddelen

### Overzicht

&okteta; biedt enige hulpmiddelen voor analyse en manipulatie van de byte-arrays en enige voor meer algemene doelen. Deze hulpmiddelen kunnen geactiveerd of gedeactiveerd worden vanuit het item Hulpmiddelen in de menubalk. Elk hulpmiddel heeft een klein venster, dat zich vastzet ofwel in een van de zijbalken of vrij zweeft als een venster. U kunt vastzetten, losmaken, opnieuw arrangeren en de hulpmiddelvensters ook met de muis stapelen, door met de &LMB; op de titel balk van een hulpmiddelvenster te drukken, het naar wens te verplaatsen en de &LMB; los te laten om de actie te voltooien, annuleer het door op de &Esc;-toets te drukken.

#### Analyzers en manipulatoren

Bytetabel

- De tabel laat alle mogelijke byte-waarden zien, zowel als teken als de numeriek waarde.

  De geselecteerde waarde kan op de cursorpositie ingevoegd worden voor een gedefinieerd aantal bytes. Dit kan bereikt worden door de knop Invoegen te gebruiken of dubbel te klikken op de regel in de tabel.

Binaire filter

- Het filter voert binaire bewerkingen uit op de geselecteerde bytes. Na het kiezen van de bewerking (EN, OF, ROTATIE..) kunnen de parameters, indien aanwezig, ingesteld worden in het onderstaande vak. Het filter wordt uitgevoerd door de knop Filter te gebruiken.

Tekenreeksen

- Dit hulpmiddel lokaliseert de tekenreeksen in de geselecteerde bytes. Na het kiezen van de minimale lengte van de tekenreeks, worden de tekenreeksen opgezocht door de knop Extraheren te gebruiken. De lijst met de getoonde tekenreeksen kan kleiner gemaakt worden door een filter in te voeren.

Statistieken

- Dit hulpmiddel bouwt een statistiek voor de geselecteerde bytes. De statistiek geeft de frequentie van voorkomen van elke bytewaarde in de selectie. Het kan berekend worden door de knop Bouwen te gebruiken.

Controlesom

- Dit hulpmiddel berekent verschillende ccontrolesommen of hashsommen voor de geselecteerde bytes. Na het kiezen van het algoritme en het instellen van de parameter, iniden nodig, zal de som berekend worden bij gebruik van de knop Berekenen.

Decoderingtabel

- De tabel toont de waarden van het byte of de bytes beginnend bij de cursor voor enkele algemene eenvoudige gegevenstypen zoals geheel getal of drijvende komma, maar ook UTF-8. Dubbelklikken op een regel in de tabel opent een editor, zodat de waarde bewerkt en gewijzigd kan worden.

Structuren

- Dit hulpmiddel schakelt onderzoeken en bewerken van byte-arrays in gebaseerd op door de gebruiker gemaakte structuurdefinities. Gedetailleerde instructies staan in een eigen sectie.

#### Algemene hulpmiddelen

Bestandssysteem

- Dit hulpmiddel biedt een ingebedde bestandenbrowser die gebruikt kan worden om te openen bestanden te selecteren.

Documenten

- Dit hulpmiddel toont alle nu aangemaakte of geladen bestanden. Symbolen markeren het bestand met de nu actieve weergave en tonen ook welke bestanden niet opgeslagen wijzigingen of welke opgeslagen kopie gewijzigd is door een ander programma.

Bladwijzers

- Dit hulpmiddel Kan worden gebruikt om de bladwijzers te beheren, als alternatief voor het menu Bladwijzers.

  Bladwijzers zijn nu slecht voorbijgaand en worden niet opgeslagen als u een byte-array of het gehele programma sluit.

Bestandsinformatie

- Dit hulpmiddel toont enige informatie over het huidige bestand, inclusief het type, de locatie van opslaan en de grootte.

### Hulpmiddel voor structuren

#### Algemeen

Het hulpmiddel Structuren schakelt analyseren en bewerking van byte-arrays in gebaseerd op door de gebruiker gemaakte structuurdefinities, die kunnen worden gebouwd uit arrays, unions, primitieve typen en een lijst met waarden.

Het heeft een eigen instellingendialoog, die bereikt wordt de knop Instellingen. Er zijn verschillende opties die ingesteld kunnen worden, zoals de stijl waarin (decimaal, hexadecimaal of binair) de waarden getoond worden. Verder is het mogelijk te kiezen welkestructuurdefinities geladen moeten worden en welke structuren getoond worden in het voorbeeld.

Structuren worden gedefinieerd in &okteta;-structuurdefinitiebestanden (gebaseerd op &XML;, met de bestandsextensie `.osd`). Verder kan een `.desktop` bestand metagegevens bevatten over dat structuurbeschrijvingsbestand, zoals auteur, homepagina en licentie.

Op dit moment is er geen ingebouwde ondersteuning voor maken of bewerken van structuurdefinities, dit moet daarom handmatig gedaan worden zoals beschreven in de volgende secties.

#### Structuurdefinities installeren

##### Met KNewStuff installeren

The easiest way of installing new structure definitions is by using the built-in KNewStuff support in &okteta;. To install an existing structure open the settings dialog of the Structures tool. There select the Structures Management tab and press the Get New Structures... button. The dialog that shows up now allows you to install and uninstall structures.

##### Structuurdefinities handmatig installeren

The Structures tool looks for structure descriptions in the subdirectory `share/apps/okteta/structures/` of the user's directory for program data (find that by executing ``kde4-config` `--localprefix``). You may need to create this directory if there are no structure definitions installed yet.

Er bestaan twee bestanden voor elke structuurdefinitie: een bestand voor de actuele definitie en een `.desktop`-bestand voor de metagegevens (auteur, versie, etc.).

In that directory there is a subdirectory for each structure definition, which contains both the `.desktop` file and the `.osd` or `main.js` file of that definition.

Bijvoorbeeld met de programmagegevensmap `.kde` en een structuurdefinitie genaamd VoorbeeldStructuur is de map `.kde/share/apps/okteta/structures/VoorbeeldStructuur`, die een bestand `VoorbeelStructuur.desktop` en een bestand `VoorbeeldStructuur.osd`.

##### De nieuwe geïnstalleerde structuren gebruiken

After having installed a new structure definition you need to restart &okteta; before you can use it. Once &okteta; has started, open the settings dialog of the Structures tool. There select the Structures Management tab and make sure the relevant structure definition is checked. Then switch to the Structures tab and make sure the desired element is listed on the right-hand side.

#### Structuurdefinities delen

For common structures you may not need to create a definition yourself, but instead can reuse an already existing definition from places like kde-files.org.

You also may want to share a definition yourself. To do so, create a file archive (⪚ a zipped tar archive, `.tar.gz`) containing just the subdirectory with the `.desktop` file and the structure definition file. Looking at the example in the last section this would be the directory `ExampleStructure` with all its contents. Using this format for sharing the structure definitions allows installing them inside &okteta; and requires no manual installation.

#### Structuurdefinities maken

There are two different ways of creating structure definitions. The first is writing the definition in &XML; the other is using JavaScript. The JavaScript approach allows you to create more complex structures with features like e.g. validating the structure. Using &XML; gives you less features but if a static structure is all you need this may be the easiest approach. If you need a dynamic structure i.e. where array lengths depend on other values in the structure or the structure layout is different when some member value changes, then you will have to write the structure definition in JavaScript. There is one exception to that rule: if you have an array where the length is supposed to be exactly the same as another value in the structure, then you can use &XML;. But if it is something like length - 1 it has to be JavaScript.

#### Structuurdefinitie &XML;-bestandsformaat

Het `.osd` &XML;-bestand heeft één basiselement: <data> zonder attributen. Binnen dit element moet er één van de volgende elementen zijn:

<primitive>

- Om een 'primitive' gegevenstype zoals bijv. int en float aan te maken. Dit element accepteert geen subelementen en kan de volgende attributen hebben:

  type

- Het type van deze primitieve type. Het moet een van de volgende zijn:

  - char voor een 8-bits ASCII-teken

  - int8, int16, int32, int64 voor een geheel getal met teken met die grootte

  - uint8, uint16, uint32, uint64 voor een geheel getal zonder teken van die grootte

  - bool8, bool16, bool32, bool64 voor een logische waarde (boolean) (0 = false, elke andere waarde = true) van die grootte

  - float voor een 32-bits IEEE754 drijvende-komma getal

  - double voor een 64-bits IEEE754 drijvende-komma getal

<bitfield>

- Om een 'bitfield' aan te maken Dit element accepteert geen subelementen en kan de volgende attributen hebben:

  breedte

- Het aantal bits gebruikt door dit 'bitfield'. Moet liggen tussen 1 en 64.

type

- Het type van dit 'bitfield'. Het moet één van de volgende zijn:

  - unsigned voor een bitfield waar de waarde geïnterpreteerd zal worden als een waarde zonder teken (waardereeks van 0 tot 2breedte - 1)

  - signed voor een bitfield waar de waarde geïnterpreteerd zal worden als een waarde met teken (waardereeks van -2breedte - 1 tot 2breedte - 1 - 1)

  - bool voor een 'bitfield' waar de waarde als een booleaanse waarde zal worden geïnterpreteerd

  Denk er aan om padding toe te voegen na een <bitfield>, omdat het volgende element anders in het midden van een byte zou beginnen (behalve voor tekenreeksen en arrays, omdat zij automatisch padding toevoegen). Als u dit gedrag wenst dan is padding natuurlijk niet nodig.

<enum>

- Om een type primitive te maken, maar waar de waarden getoond worden, indien mogelijk, als leden van een enumeratie. Dit element accepteert geen subelementen (maar u hebt mogelijk een tag <enumDef> in het bestand nodig om er naar te refereren). Het heeft de volgende attributen:

  enum

- De onderliggende 'enum' voor deze waarde. Moet overeenkomen met het attribuut name van één van de tags <enumDef> in dit bestand.

type

- Het type hiervan is enum. Zie type attribuut van <primitive>. Het enige verschil is dat Double en Float geen betekenis hebben.

<flags>

- This is the same as <enum> with the only difference being that values are represented as a bitwise-or of all the values of the enumeration.

<struct>

- To create a structure. All other elements (including <struct>) can be a child of this and will then be part of the resulting structure

<union>

- To create a union. Basically the same as <struct> except for the fact that all child elements will start from the same offset. Useful for interpreting the same sequence of bytes in various ways.

<array>

- To create an array. This element accepts exactly one child (the underlying type of the array), which can be any of the elements, even <array> itself. It also has the following attributes:

  lengte

- The number of elements in this array as a decimal number. Alternatively it can also be a string which matches the name attribute of a previously defined <primitive>, <enum> or <flags> element. Then the length will be the value of that element. Currently it is limited to 10000, because larger arrays would use too much memory and slow down the tool too much.

<string>

- To create a string in various encodings. By default you get a NULL- terminated C-style string. However different types of string can be created with the following attributes:

  terminatedBy

- This attribute determines what unicode codepoint the string is terminated by. It must be a hexadecimal number (optionally with leading 0x). When encoding is ASCII, only values up to 0x7f are meaningful. If neither this nor maxCharCount nor maxByteCount are set, this is assumed to be set to 0 (C-style string)

maxCharCount

- The maximum number of chars this string can have. If terminatedBy is set too then whatever is reached first terminates the string. This is mutually exclusive with maxByteCount

maxByteCount

- The maximum number of bytes this string can be long. If terminatedBy is set too then whatever is reached first terminates the string. This is mutually exclusive with maxCharCount. With encodings like ASCII this is the same as maxCharCount.

type

- De codering van deze tekenreeks. Kan een van de volgende zijn:

  - ASCII

  - LATIN-1

  - UTF-8

  - UTF-16-LE of UTF-16-BE. Als geen -LE of -BE achtervoegsel is gegeven, wordt 'little endian' aangenomen.

  - UTF-32-LE of UTF-32-BE. Als geen -LE of -BE achtervoegsel is gegeven, wordt 'little endian' aangenomen.

Elk element accepteert ook een attribuut name dat dan zichtbaar is in de structurenweergave.

#### Een voorbeeld van een structuurdefinitie in zowel &XML; als JavaScript

##### De gezamelijke stap gedeeld door beide benaderingen

Ons bestand met metagegevens ziet er zo uit:

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

            Name=Simpele teststructuur
            Comment=Een erg simpele teststructuur met slechts twee items

            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

- Het pictogram getoond in &okteta; voor deze structuur kan alles zijn wat gevonden wordt door ``kdialog` `--geticon`` uit te voeren of een pad naar een pictogram

Deze velden zouden allemaal zichzelf moeten verklaren, behalve voor `X-KDE-PluginInfo-Name`. De waarde van dit veld moet overeenkomen met de naam van de map met het bestand evenals de naam van het `.desktop`-bestand. Bij het maken van &XML;-structuurdefinities zal de naam van het `.osd` bestand ook met de naam overeen moeten komen.

In this example we would have a directory named `simplestruct` containing the file `simplestruct.desktop`. When defining structures in &XML; the directory would also contain a file named `simplestruct.osd`. Using JavaScript we would have a file named `main.js` instead.

##### Een eenvoudige &XML;-structuurdefinitie

To start we create a definition for a very simple test structure containing only integral data types (one char, one 32-bit signed integer, and a bitfield). This would be expressed in C/C++ as:

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

The first step is writing the `.osd` file according to the file format defined in the previous section. We will call `simplestruct.osd`:

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

which is fairly similar to the C/C++ definition.

Now create a directory `simplestruct` inside the structure installation directory (see manually installing structure definitions) and copy the two files to this directory. Now you can restart &okteta; and use the new structure.

##### De eenvoudige structuur in JavaScript

To implement the structure above in JavaScript, create a file named `main.js` instead of `simplestruct.osd`. The contents of that file should be:

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

The structure displayed by &okteta; is always the return value of the `init` function.

The following functions can be called to create a primitive type:

- char()

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

- uint8(), uint16(), uint32() or uint64()

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

- float()

- double()

The bitfield function takes two parameters, the first being a string consisting of `bool`, `signed` or `unsigned`. The second parameter is an integer which sets the width in bits.

##### Complexere structuren

Next we create a definition of a more complex structure which we will call "complex" and save in a file named `complex.osd`. This structure will contain two arrays (one with fixed length and one where the length is determined at runtime) as well as a nested structure and a union.

              <?xml version="1.0" encoding="UTF-8"?>
              <data>
                <struct name="complex">
                  <primitive name="size" type="UInt8" />
                  <union name="aUnion">
                    <array name="fourBytes" length="4">
                      <primitive type="Int8" />
                    </array>
                  </union>
                  <struct name="nested">
                    <array name="string" length="size"> <!-- references the field size above -->
                      <primitive type="Char" />
                    </array>
                  </struct>
                </struct>
              </data>

This would correspond to the following in pseudo-C/C++

    struct complex {
                uint8_t size;
                union aUnion {
                  int8_t fourBytes[4];
                };
                struct nested {
                  char string[size] //geen geldige C++, refereert waarde van de grootte uint8
                };
              };

You can obviously only have dynamic length arrays reference fields before the array.

Vervolgens maken we het bestand `complex.desktop` net als in het vorige voorbeeld (ga na dat u `X-KDE-PluginInfo-Name` juist instelt) en ook hetzelfde doet om beide bestanden te installeren.

##### Meer informatie

A few example structure definitions can be found here. This includes for example the file header for PNG files and the ELF file header. An &XML; schema describing the structure of the `.osd` file can be found here. If more information is needed feel free to contact me at &Alex.Richardson.email;

## Menuopties

Merk op dat de meeste menucommando's een sneltoets hebben.

### Menu Bestand

&Ctrl;N Bestand Nieuw

- Een nieuw byte-array aanmaken...

  - Leeg: ... zoals een lege.

  - Van klembord: ... door de huidige inhoud van het klembord.

  - Patroon...: ... met een gegeven patroon.

  - Willekeurige gegevens...: ...met willekeurige gegevens.

  - Reeks: ... met alle bytes van 0 tot 255.

&Ctrl;O Bestand Openen...

- Een bestaand bestand openen.

Bestand Recent geopend

- Kies uit een lijst van de laatst geopende bestanden.

&Ctrl;S Bestand Opslaan

- Byte-array opslaan naar het toegekende bestand.

Bestand Opslaan als...

- Byte-array opslaan naar een ander bestand met een nieuwe naam.

Bestand Exporteren

- De geselecteerde bytes naar een bestand exporteren...

  - Values: ... gecodeerd als byte-waarden.

  - Plain Text: ... gecodeerd als tekens.

  - Base64: ... gecodeerd in het Base64-formaat.

  - C array: ... gedefinieerd als een array in de programmeertaal C.

  - In platte tekst bekijken: ... zoals in de gegevensweergave met offset, waarden van bytes en tekens.

F5 Bestand Herladen

- Laat alle wijzigingen vallen en herlaadt het byte-array uit het bestand.

&Ctrl;P Bestand Afdrukken...

- Het huidige byte-array afdrukken.

Bestand Toegangsrechten

- Wijzigingsrechten instellen:

  Op alleen-lezen ingesteld

- Er kunnen mogelijk geen wijzigingen worden gemaakt in het geladen byte-array, indien geactiveerd.

&Ctrl;W Bestand Sluiten

- Het huidige byte-array sluiten.

Bestand Alles sluiten

- Alle byte-arrays sluiten.

Bestand Alle anderen sluiten

- Sluit alles behalve het huidige byte-array.

&Ctrl;Q Bestand Afsluiten

- Sluit het venster van &okteta;.

### Menu Bewerken

Op dit moment, in &kde; 4.4, is het eenvoudig kopiëren en knippen van gegevens naar het klembord met het mime-type "application/octetstream", niet is &klipper; in staat om deze gegevens te tonen. En bijna alle andere toepassingen kunnen het ook niet behandelen, omdat het eenvoudige ruwe gegevens zijn. Zie dus ook het submenu Kopiëren als.

&Ctrl;Z Bewerken Ongedaan maken

- Maakt de laatste handeling ongedaan.

&Ctrl;&Shift;Z Bewerken Opnieuw

- Voert de laatste handeling opnieuw uit.

&Ctrl;X Bewerken Knippen

- De geselecteerde bytes verwijderen en naar het klembord kopiëren.

&Ctrl;C Bewerken Kopiëren

- De geselecteerde bytes naar het klembord kopiëren.

&Ctrl;V Bewerken Plakken

- De geknipte of gekopieerde bytes invoegen in het klembord.

Bewerken Kopiëren als

- De geselecteerde bytes naar het klembord kopiëren...

  - Values: ... gecodeerd als byte-waarden.

  - Plain Text: ... gecodeerd als tekens.

  - Base64: ... gecodeerd in het Base64-formaat.

  - C array: ... gedefinieerd als een array in de programmeertaal C.

  - In platte tekst bekijken: ... zoals in de gegevensweergave met offset, waarden van bytes en tekens.

Bewerken Invoegen

- Patroon invoegen...

- Voeg een gespecificeerde tekenreeks met bytes in bij de cursor.

  Opties in het dialoogvak stellen u in staat het aantal keren invoegen van het patroon te specificeren en het formaat (hexadecimaal, decimaal, octaal, binair, teken(s) of UTF-8).

&Ctrl;A Bewerken Alles selecteren

- Selecteer het gehele array met bytes.

&Ctrl;&Shift;A Bewerken Deselecteren

- Maak de huidige selectie ongedaan.

&Ctrl;E Bewerken Bereik selecteren...

- Opent een ingebedde dialoog om het te selecteren bereik in te voeren.

Ins Bewerken Overschrijfmodus

- Schakelen tussen de modi Invoegen en Overschrijven.

  De modus overschrijven is erg strikt geïmplementeerd, het is niet mogelijk om de grootte van de gegevens te wijzigen (geen toevoegen of verwijderen van bytes).

&Ctrl;F Bewerken Zoeken...

- Zoek naar een gespecificeerd patroon in het document. Er kan naar hexadecimale, decimale, octale, binaire of tekstpatronen worden gezocht.

  Opties in het dialoogvak stellen u in staat om het beginpunt, richting en zoekgebied te specificeren.

F3 Bewerken Volgende zoeken

- Zoek het volgende exemplaar van het Zoekpatroon.

  Als er geen patroon is gespecificeerd, zal het dialoogvak worden getoond.

&Shift;F3 Bewerken Vorige zoeken

- Zoek het vorige exemplaar van het Zoekpatroon.

  Als er geen patroon is gespecificeerd, zal het dialoogvak worden getoond.

&Ctrl;R Bewerken Vervangen...

- Vervang het gevonden patroon door een ander patroon.

&Ctrl;G Bewerken Ga naar offset...

- De cursor naar een gespecificeerde offset verplaatsen.

### Menu Beeld

&Ctrl;+ Beeld Inzoomen

- De afmeting van het lettertype vergroten.

&Ctrl;- Beeld Uitzoomen

- De afmeting van het lettertype verkleinen.

Beeld Niet-afdrukbare karakters tonen

- Aan/uitzetten van het tonen van niet-afdrukbare tekens. Als de weergave is uitgezet, wordt in plaats daarvan, op de overeenkomstige plaatsen in de kolom voor het teken, een vervangend teken getoond.

F11 Beeld Regeloffset tonen

- Aan/uitzetten van het tonen van de regeloffset in een paneel links.

Beeld Waarden of tekens tonen

- Selecteer welke van de interpretaties van een byte getoond wordt. Mogelijk zijn:

  - Waarden

  - Tekens

  - Waarden en tekens

Beeld Waardecodering

- Selecteer de codering van de waarden uit:

  - Hexadecimaal

  - Decimaal

  - Octaal

  - Binair

Beeld Tekencodering

- Selecteer de codering van de tekens uit het submenu.

Beeld Dynamische opmaak

- Stel de regels in voor de opmaak van de gegevensweergave. Dit definieert hoeveel bytes per regel er worden getoond, afhankelijk van de breedte van het beeld. Mogelijke regels zijn:

  - Uit: De opmaak is vast en gelijk aan het huidige aantal bytes per regel en niet aangepast aan de wijziging van de grootte van het beeld.

  - Breek alleen af op volledige bytegroepen: Zet zoveel mogelijk bytes op een regel, zolang groepen bytes kompleet zijn.

  - Aan: Hetzelfde als de vorige, maar staat ook onvolledige groepen bytes toe.

Beeld Weergavemodus

- Selecteer de opmaak van het beeld uit:

  - Kolommen: De waarden en tekens worden op de klassieke manier getoond met elk in een aparte kolom.

  - Rijen: Het bijbehorende teken van een byte wordt direct onder de waarde getoond.

&Ctrl;&Shift;T Beeld Horizontaal splitsen

- Splits het weergavegebied met het huidige beeld met focus in twee delen en voeg een kopie van het huidige beeld in het nieuwe onderste gedeelte.

&Ctrl;&Shift;L Beeld Verticaal splitsen

- Splits het weergavegebied met het huidige beeld met focus in twee delen en voeg een kopie van het huidige beeld in het nieuwe rechter gedeelte.

&Ctrl;&Shift;R Beeld Weergavegebied sluiten

- Sluit het weergavegebied met het huidige beeld met focus.

Beeld Profiel weergeven

- View settings can be separately stored as view profiles. The currently selected profile can be updated directly from the current view settings, or a new one can be created from them. All view profiles can be managed in a dialog available from Settings Manage View Profiles....

### Menu Vensters

Levert een lijst met de huidige beelden. Selecteer het actieve venster.

### Het menu Bladwijzers

Meerdere bladwijzers kunnen worden ingesteld voor een enkele reeks bytes. Elke reeks bytes heeft zijn eigen set bladwijzers en de bijbehorende set is onderaan het menu Bladwijzers weergegeven. Kies een bladwijzer uit het menu om de cursor te verplaatsen en het te bekijken.

Bladwijzers zijn nu slecht voorbijgaand en worden niet opgeslagen als u een byte-array of het gehele programma sluit.

&Ctrl;B Bladwijzers Bladwijzer toevoegen

- Locatie in een aantal bytes als bladwijzer instellen.

&Ctrl;&Shift;B Bladwijzers Bladwijzer verwijderen

- De huidige bladwijzer verwijderen. Dit commando is alleen beschikbaar als de cursor op een locatie in een bladwijzer staat.

Bladwijzers Alle bladwijzers wissen

- De lijst met bladwijzers wissen.

&Alt;Omhoog Bladwijzer Ga naar de vorige bladwijzer

- Beweeg de cursor naar de vorige bladwijzer.

&Alt;Omlaag Bladwijzer Ga naar de volgende bladwijzer

- Beweeg de cursor naar de volgende bladwijzer.

### Menu hulpmiddelen

Levert een lijst met geïnstalleerde hulpmiddelen. Schakel de weergave van elk hulpmiddel aan of uit. Een gedetailleerde beschrijving van elk hulpmiddel is te vinden in de sectie Hulpmiddelen.

### Menu Instellingen

Instellingen Weergaveprofielen beheren...

- Open een dialoog om een standaard profiel aan te maken, te bewerken, te verwijderen of in te stellen.

Instellingen Werkbalk tonen

- Weergave van de werkbalk onder de menubalk aan-/uitzetten.

Instellingen Statusbalk tonen

- Tonen van de statusbalk aan/uit.

&Ctrl;&Shift;F Instellingen Volledig scherm

- Omschakelen naar volledig scherm of terug.

Instellingen Sneltoetsen instellen...

- Sneltoetsen behorende bij acties van het programma wijzigen.

Instellingen Werkbalken instellen...

- De inhoud van de werkbalk beheren.

### Menu Help

&help.menu.documentation;

### Werkbalk

De werkbalk bevat pictogrammen voor de volgende acties:

(De functionaliteit is overigens identiek aan de opties uit het menu)

- Nieuw

- Openen

- Opslaan

- Opslaan als

- Ongedaan maken

- Opnieuw

- Knippen

- Kopiëren

- Plakken

- Zoeken

- Volgende zoeken

## Verdiensten en licentie

&okteta;

Programma Copyright 2006-2012 &Friedrich.Kossebau; &Friedrich.Kossebau.email;

Documentatie Copyright 2008,2010 &Friedrich.Kossebau; &Friedrich.Kossebau.email;, &Alex.Richardson; &Alex.Richardson.email;

&meld.fouten;&vertaling.freek; &underFDL; &underGPL;

## Installatie

### Hoe &okteta; te verkrijgen

&install.intro.documentation;

### Compilatie en installatie

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