# El manual de &okteta;

Friedrich
W. H.
Kossebau

    &Friedrich.Kossebau.email;

Alex
Richardson

    &Alex.Richardson.email;

Ignacio
Poggi

    ignaciop.3@gmail.com

Traductor
2008, 2010, 2011
&Friedrich.Kossebau; y &Alex.Richardson;
&FDLNotice;
2018-03-23
&okteta; 0.24.60

&okteta; es un editor sencillo para archivos y datos en bruto. Este tipo de programa también se conoce como editor hexadecimal o binario.

KDE
Okteta
ver
edición
bits
bytes
binario
octal
hexadecimal
editor hexadecimal
datos en bruto

## Introducción

&okteta; es un editor sencillo para datos en bruto de archivos.

Los datos se muestran de dos formas distintas: como valores numéricos de los bytes y como los caracteres asignados a los valores. Los valores y los caracteres se pueden mostrar separados en dos columnas o uno junto al otro con el valor sobre el carácter. Es posible editar tanto los valores como los caracteres.

Además de las capacidades usuales de edición, &okteta; proporciona un reducido conjunto de herramientas, como una tabla que lista descodificaciones en tipos de datos comunes, una tabla que lista todos los bytes posibles con sus caracteres y valores equivalentes, un visor de información con estadísticas, una calculadora de sumas de verificación, una herramienta de filtrado y una herramienta de extracción de cadenas.

Todas las modificaciones realizadas sobre los datos cargados se pueden deshacer y rehacer sin ningún tipo de límite.

## Bases

### Iniciando &okteta;

Escriba ``okteta`` en el intérprete de órdenes o seleccione Editor hexadecimal en el grupo Aplicaciones Utilidades del lanzador de aplicaciones.

Las opciones de la línea de órdenes estándar de &Qt; y &kf5-full; se encuentran disponibles. Puede listarlas introduciendo ``okteta` `--help``.

Las opciones específicas de la línea de órdenes para &okteta; son:

`<&URL;(s)>` - abrir archivo(s) desde el(los) &URL; especificado(s)

### Uso

La ventana principal de &okteta; tiene los siguientes componentes: una barra de menú, una barra de herramientas, una barra de estado, una o más barras laterales con herramientas y vista principal con pestañas que contienen visores de datos.

Cuando se abre un archivo o se crea un nuevo array de bytes, los bytes que contiene se listan consecutivamente en líneas con un determinado número de bytes por línea. Se muestran de dos formas distintas: como valores numéricos de los bytes y como los caracteres asignados a los valores. Los valores y los caracteres se pueden mostrar separados en dos columnas o uno junto al otro con el valor sobre el carácter. En la parte izquierda se muestran los desplazamientos del primer byte de cada línea.

El manejo es similar al común en muchos editores de textos: los datos se pueden editar, cortar, copiar, pegar, arrastrar y soltar como el texto dentro de un editor de textos. Un cursor marca la posición actual. Si pulsa la tecla Insert, cambiará entre los modos sobrescribir e insertar. El modo de sobrescritura es más estricto que en los editores de texto, ya que no permite ninguna operación que modifique el tamaño del array de bytes.

Al contrario que en los editores de texto, el contenido se muestra de dos formas distintas. Solo una de ellas está activa para introducir datos. Se muestran dos cursores enlazados para los visores de valores y de caracteres. El cursor activo parpadea. Si están activos los caracteres, podrá introducir caracteres del mismo modo que en los editores de texto. Si están activos los valores, al escribir un dígito se abrirá un pequeño editor para introducir el resto del valor.

El diálogo de búsqueda permite al usuario buscar una cadena específica de bytes, que se puede definir como valores (hexadecimales, decimales, octales, binarios) o texto (con la codificación actual de 8 bits o como UTF-8).

Se pueden abrir varios arrays de bytes simultáneamente, pero solo uno puede estar activo. Use el menú Ventana para seleccionar el array de bytes que estará activo.

## Herramientas

### Introducción

&okteta; contiene varias herramientas, algunas para analizar y manipular arrays de bytes y otras para otros propósitos más generales. Estas herramientas se pueden activar o desactivar desde la entrada Herramientas de la barra de menú. Cada herramienta posee un pequeño visor que se puede anclar en cualquiera de las barras laterales o flotar libremente como una ventana. Puede anclar, desanclar, reorganizar y también apilar los visores de las herramientas con el ratón, pulsando el &LMB; sobre la barra de título del visor de la herramienta, moviéndolo como desee y soltando el &LMB; para completar la acción; puede cancelar la operación pulsando la tecla &Esc;.

#### Analizadores y manipuladores

Tabla de valores/caracteres

  La tabla hace un listado de todos los valores posibles de byte, tanto en forma caracteres como en diferentes codificaciones numéricas.

  El valor seleccionado puede ser insertado en la posición del cursor para un número definido de bytes. Esto puede ser logrado usando el botón Insertar o haciendo doble clic en la línea de la tabla.

Filtro binario

  El filtro realiza operaciones binarias en los bytes seleccionados. Después de elegir la operación (AND, OR, ROTATE...), los parámetros, si hay alguno, pueden ser configurados en el cuadro de diálogo que se muestra debajo. El filtro se ejecuta al usar el botón Filtro.

Cadenas

  Esta herramienta localiza las cadenas en los bytes seleccionados. Tras escoger una longitud mínima para la cadena y pulsar el botón Extraer, las cadenas se buscarán con la herramienta «grep». Se puede reducir la lista de cadenas mostradas introduciendo algún término para filtrarlas.

Estadísticas

  La herramienta crea una estadística para los bytes seleccionados. La estadística proporciona la frecuencia de aparición de cada byte en la selección. Se puede calcular usando el botón Construir.

Suma de verificación

  Esta herramienta calcula varias sumas de verificación o de «hash» para los bytes seleccionados. Tras escoger el algoritmo y ajustar el parámetro, si hay uno, se calcula la suma al usar el botón Calcular.

Tabla de decodificación

  La tabla muestra los valores del byte o de los bytes comenzando en la posición del cursor para algunos tipos de datos sencillos y comunes, como enteros o valores en coma flotante, así como UTF-8. Si hace doble clic sobre una línea de la tabla se abrirá un editor en el que podrá editar y cambiar el valor.

Estructuras

  Esta herramienta activa la investigación y la edición de arrays de bytes basados en definiciones de estructuras creadas por el usuario. Las instrucciones detalladas están en una sección propia.

#### Herramientas generales

Sistema de archivos

  Esta herramienta ofrece un navegador de archivos integrado que se puede usar para seleccionar los archivos a abrir.

Documentos

  Esta herramienta muestra todos los archivos actualmente creados o cargados. Los símbolos marcan el archivo en la vista actualmente activa y también muestran qué archivos contienen modificaciones sin guardar o qué copias almacenadas han sido modificadas por otro programa.

Marcadores

  Esta herramienta se puede usar para gestionar los marcadores de forma alternativa al menú Marcadores.

  Los marcadores son temporales en la actualidad y no se guardan si cierra el array de bytes o el programa.

Información sobre el archivo

  Esta herramienta muestra información sobre el archivo actual, incluyendo su tipo, su ubicación de almacenamiento y su tamaño.

Terminal

  Una terminal integrada; el directorio de trabajo no está enlazado con el archivo activo.

Conversión de juegos de caracteres

  La herramienta reescribe los bytes de modo que los respectivos caracteres sean los mismos que con el otro juego de caracteres. Solo se permite el uso de juegos de caracteres de 8 bits. Los caracteres sin correspondencia se sustituyen en la actualidad por el valor 0.

### Herramienta de estructuras

#### General

La herramienta de estructuras permite el análisis y la edición de arrays de bytes basados en definiciones de estructuras creadas por el usuario, que se pueden construir a partir de arrays, uniones, tipos primitivos y valores de enumeración.

Posee un diálogo de ajustes propio, que se puede mostrar usando el botón Ajustes. Existen varias opciones que se pueden configurar, como el estilo (decimal, hexadecimal o binario) en el que se muestran los valores. También es posible escoger qué definiciones de estructuras se cargan y qué estructuras se muestran en el visor.

Las estructuras se definen en archivos de definición de estructuras de &okteta; (basados en &XML;, con la extensión `.osd`). Adicionalmente, un archivo `.desktop` contiene metadatos sobre dicho archivo de descripción de estructura, como el autor, su página web y la licencia de uso.

En la actualidad no se pueden crear ni editar definiciones de estructuras desde dentro del programa, por lo que estas operaciones se deben realizar de forma manual como se describe en las siguientes secciones.

#### Instalación de definiciones de estructuras

##### Instalación usando KNewStuff

El modo más fácil para instalar nuevas definiciones de estructuras consiste en usar la utilidad KNewStuff integrada en &okteta;. Para instalar una estructura existente, abra el diálogo de preferencias de la herramienta «Estructuras». Seleccione ahí la pestaña Gestión de estructuras y pulse el botón Obtener nuevas estructuras.... El diálogo que se muestra a continuación le permite instalar y desinstalar estructuras.

##### Instalación manual de definiciones de estructuras

La herramienta de estructuras comprueba la existencia de descripciones de estructuras en el subdirectorio `okteta/structures/` del directorio del usuario para los datos de programas (puede encontrarlo ejecutando ``qtpaths` `--paths GenericDataLocation``). Es posible que tenga que crear este directorio si aún no ha instalado ninguna definición de estructura.

Existen dos archivos para cada definición de estructura: uno para la definición y otro con la extensión `.desktop` para los metadatos (autor, versión, etc.).

En este directorio existe un subdirectorio para cada definición de estructura, que contiene tanto el archivo `.desktop` como el archivo `.osd` o el archivo `main.js` de la definición.

Por ejemplo, con el directorio de datos de programas ```qtpaths` `--paths GenericDataLocation``` y una definición de estructura llamada «EstructuraEjemplo», existirá el directorio `okteta/structures/EstructuraEjemplo`, que contendrá los archivos `EstructuraEjemplo.desktop` y `EstructuraEjemplo.osd`.

##### Uso de las estructuras recién instaladas

Si ha instalado una nueva definición de estructura, tendrá que reiniciar &okteta; antes de poder usarla. Tras iniciar &okteta;, abra el diálogo de preferencias de la herramienta de estructuras. Seleccione allí la pestaña Gestión de estructuras y asegúrese de marcar la definición de estructura en cuestión. Cambie luego a la pestaña Estructuras y asegúrese de que el elemento en cuestión aparece listado en la parte de la derecha.

#### Compartir definiciones de estructuras

No necesita crear una definición para las estructuras comunes, pero sí puede reutilizar alguna definición existente de sitios como store.kde.org.

También es posible que quiera compartir una definición. Para ello, cree un archivo comprimido (&eg;, un archivo comprimido tar, `.tar.gz`) que contenga únicamente el subdirectorio con el archivo `.desktop` y el archivo de definición de la estructura. Según el ejemplo de la sección anterior, sería el directorio `EstructuraEjemplo` con todo su contenido. El uso de este formato para compartir las definiciones de estructuras permite instalarlas en &okteta; sin tener que hacerlo manualmente.

#### Creación de definiciones de estructuras

Puede encontrar una guía más actualizada (aunque incompleta) para escribir definiciones de estructuras en la Wiki de KDE UserBase.

Existen dos modos diferentes de crear definiciones de estructuras. El primero consiste en escritor la definición en &XML;, mientras que el otro usa JavaScript. La aproximación en JavaScript le permite crear estructuras más complejas con funcionalidades como, &eg;, la de validar la estructura. El uso de &XML; le proporciona menos funcionalidades, aunque el más sencillo si lo único que necesita es una estructura estática. Si lo que necesita es una estructura dinámica (es decir, en la que la longitud de los arrays depende de otros valores de la estructura, o el esquema de la estructura es diferente cuando cambian algunos valores miembro), tendrá que escribir la definición de la estructura en JavaScript. Existe una excepción a esta regla: si tiene un array cuya longitud se supone que es exactamente la misma que otro valor de la estructura, podrá usar &XML;. Pero si es algo como longitud - 1, debe usar JavaScript.

#### Formato de archivo &XML; de definición de estructuras

Puede encontrar una guía más actualizada (aunque incompleta) para escribir definiciones de estructuras en la Wiki de KDE UserBase.

El archivo &XML; con la extensión `.osd` tiene un elemento raíz: <data>, que no posee atributos. Dentro de este elemento debe existir uno de los siguientes elementos:

<primitive>

  Para crear tipos de datos de primitivas como, &eg;, int y float. Este elemento no acepta subelementos y puede tener los siguientes atributos:

  type

    El tipo de esta primitiva. Debe ser uno de los siguientes:

    - char para un carácter ASCII de 8 bits

    - int8, int16, int32, int64 para enteros con signo del tamaño indicado

    - uint8, uint16, uint32, uint64 para enteros sin signo del tamaño indicado

    - bool8, bool16, bool32, bool64 para booleanos sin signo (0 = falso, cualquier otro valor = cierto) del tamaño indicado

    - float para números en coma flotante IEEE754 de 32 bits

    - double para números en coma flotante IEEE754 de 64 bits

<bitfield>

  Para crear un campo de bits. Este elemento no acepta subelementos y puede tener los siguientes atributos:

  width

    El número de bits que usa este campo de bits. Debe estar comprendido entre 1 y 64.

  type

    El tipo de este campo de bits. Debe ser uno de los siguientes:

    - unsigned para un campo de bits donde el valor se interpretará como valor sin signo (comprendido entre 0 y 2width - 1)

    - signed para un campo de bits donde el valor se interpretará como valor con signo (comprendido entre -2width - 1 y 2width - 1 - 1)

    - bool para un campo de bits donde el valor se interpretará como booleano

    Recuerde añadir siempre un relleno tras un <bitfield>, ya que, de lo contrario, el siguiente elemento comenzará en medio de un byte (excepto con cadenas y arrays, que añaden relleno de forma automática). Por supuesto, el relleno no será necesario si quiere este comportamiento.

<enum>

  Para crear un tipo de primitiva, excepto donde los valores se muestran como miembros de una enumeración, si es posible. Este elemento no acepta ningún subelemento (en caso contrario necesitaría una etiqueta <enumDef> en el archivo para hacer referencia a él). Posee los siguientes atributos:

  enum

    El enumerador subyacente para este valor. Debe concordar con el atributo name de una de las etiquetas <enumDef> de este archivo.

  type

    El tipo de este enumerador. Consulte el atributo tipo de <primitive>. La única diferencia es que Double y Float no tienen sentido.

<flags>

  Esto es lo mismo que <enum> con la única diferencia de que los valores se representan como un bitwise-or de todos los valores de la enumeración.

<struct>

  Para crear una estructura. El resto de elementos (incluido <struct>) pueden ser hijos de este, en cuyo caso serán parte de la estructura resultante.

<union>

  Para crear una unión. En esencia es lo miso que <struct>, excepto por el hecho de que todos los elementos hijos comenzarán desde el mismo desplazamiento. Resulta útil para interpretar la misma secuencia de bytes de diferentes modos.

<array>

  Para crear un array. Este elemento acepta únicamente un hijo (el tipo subyacente del array), que puede ser cualquiera de los elementos, incluso el mismo <array>. También posee los siguientes atributos:

  length

    El número de elementos del array como número decimal. De forma alternativa, también puede ser una cadena que coincida con el atributo de nombre de un elemento <primitive>, <enum> o <flags> previamente definido. En este caso, la longitud será el valor de dicho elemento. En la actualidad está limitado a 10000, ya que un array mayor usaría demasiada memoria y haría que el programa fuese muy lento.

<string>

  Para crear una cadena con diferentes codificaciones. Por omisión, obtendrá una cadena de estilo C terminada con NULL. No obstante, se pueden crear distintos tipos de cadenas con los siguientes atributos:

  terminatedBy

    Este atributo determina con qué código unicode termina la cadena. Debe ser un número hexadecimal (que puede comenzar por 0x). Cuando se usa la codificación ASCII, solo tienen sentido los valores inferiores a 0x7f, incluido. Si no se indica este valor ni maxCharCount ni maxByteCount, se asume que es 0 (cadena de estilo C)

  maxCharCount

    El número máximo de caracteres que puede contener la cadena. Si también se especifica terminatedBy, la cadena se terminará con cualquiera de los dos que se alcance primero. Esto es mutuamente exclusivo con maxByteCount

  maxByteCount

    El número máximo de bytes que esta cadena puede tener de longitud. Si también se especifica terminatedBy, la cadena se terminará con cualquiera de las dos que se alcance primero. Esto es mutuamente exclusivo con maxCharCount. Con codificaciones como ASCII es idéntico a maxCharCount.

  type

    La codificación de la cadena. Puede ser una de las siguientes:

    - ASCII

    - LATIN-1

    - UTF-8

    - UTF-16-LE o UTF-16-BE. Si no se indica uno de los sufijos -LE o -BE, se asume «little endian».

    - UTF-32-LE o UTF-32-BE. Si no se indica uno de los sufijos -LE o -BE, se asume «little endian».

Todos los elementos aceptan también el atributo name, que es visible en las vistas de las estructuras.

#### Un ejemplo de definición de estructura en &XML; y en JavaScript

Puede encontrar una guía más actualizada (aunque incompleta) para escribir definiciones de estructuras en la Wiki de KDE UserBase.

##### El paso en común compartido por ambas aproximaciones

Nuestro archivo de metadatos sería semejante al siguiente:

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

              Name=Estructura de prueba simple
              Comment=Una estructura de prueba muy sencilla que solo contiene dos elementos

              X-KDE-PluginInfo-Author=Alex Richardson
              X-KDE-PluginInfo-Email=mi.direccion@email.org
              X-KDE-PluginInfo-Name=estructurasimple
              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

El icono que muestra &okteta; para esta estructura puede ser cualquier cosa que encuentre al ejecutar ``kdialog` `--geticon`` o una ruta a un icono

Estos campos deberían resultar autoexplicativos, excepto `X-KDE-PluginInfo-Name`. El valor de este campo debe tener el nombre del directorio que contiene el archivo, así como el nombre del archivo `.desktop`. Al crear las definiciones de una estructura &XML;, el nombre del archivo `.osd` debe coincidir con el nombre.

En este ejemplo tendremos un directorio llamado `estructurasimple` que contendrá el archivo `estructurasimple.desktop`. Al definir estructuras en &XML;, el directorio también contendrá un archivo llamado `estructurasimple.osd`. Si usáramos JavaScript tendremos en su lugar un archivo llamado `main.js`.

##### Una definición de estructura sencilla en &XML;

Para comenzar vamos a crear una definición para una estructura de pruebas muy simple que solo contiene tipos de datos enteros (un carácter, un entero de 32 bits y un campo de bits). Esto se expresaría en C/C++ del siguiente modo:

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

El primer paso es escribir el archivo `.osd` según el formato de archivo descrito en la sección anterior. Lo llamaremos `estructurasencilla.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>

que es bastante similar a la definición de C/C++.

Ahora debe crear un subdirectorio `estructurasimple` dentro del directorio de instalación de la estructura (consulte la instalación manual de definiciones de estructuras) y copiar los dos archivos en dicho directorio. Luego tendrá que reiniciar &okteta; para poder usar la nueva estructura.

##### La misma estructura en JavaScript

Para implementar la estructura anterior en JavaScript, cree un archivo llamado `main.js` en lugar de `simplestruct.osd` y cambie X-KDE-PluginInfo-Category=structure a X-KDE-PluginInfo-Category=structure/js. El contenido de este archivo debe ser:

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

La estructura mostrada por &okteta; es siempre el valor devuelto por la función `init`.

Puede llamar a las siguientes funciones para crear un tipo de primitiva:

- char()

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

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

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

- float()

- double()

La función «bitfield» tiene dos parámetros: el primero es una cadena que contiene `bool`, `signed` o `unsigned`; el segundo parámetro es un entero que establece el ancho en bits.

##### Estructuras más complejas

A continuación crearemos una definición de una estructura más compleja que llamaremos «compleja» y guardaremos en un archivo llamado `compleja.osd`. Esta estructura contendrá dos arrays (uno de longitud fija y otro donde la longitud se determina en tiempo de ejecución), así como una estructura anidada y una unión.

              <?xml version="1.0" encoding="UTF-8"?>
              <data>
                <struct name="compleja">
                  <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"> <!-- hace referencia a la longitud del campo anterior -->
                      <primitive type="Char" />
                    </array>
                  </struct>
                </struct>
              </data>

Esto se correspondería con el siguiente pseudocódigo C/C++

    struct complex {
                uint8_t size;
                union aUnion {
                  int8_t fourBytes[4];
                };
                struct nested {
                  char string[size] //no válido en C++, hace referencia a valor de tamaño uint8
                };
              };

Obviamente, solo puede tener campos de referencia a arrays de longitud dinámica antes del propio array.

A continuación creamos el archivo `compleja.desktop` del mismo modo que en el ejemplo anterior (asegúrese de fijar el valor `X-KDE-PluginInfo-Name` correctamente) y haga lo mismo para instalar ambos archivos.

##### Más información

Puede encontrar unas cuantas definiciones de estructuras de ejemplo en el repositorio Git. Encontrará, por ejemplo, las cabeceras de los archivos PNG y ELF. Puede encontrar un esquema &XML; que describe la estructura de los archivos `.osd` aquí. Si necesita más información, contacte conmigo en &Alex.Richardson.email;.

## Introducción a la interfaz

### Elementos del menú

Además de los menús comunes de &kde; descritos en el capítulo Menú de la documentación de los Fundamentos de &kde;, &okteta; posee las siguientes entradas de menú específicas de la aplicación:

#### Menú Archivo

&Ctrl;N Archivo Nuevo

  Crear un nuevo array de bytes...

  - Vacío: ... como vacío.

  - Desde el portapapeles: ... con el contenido actual del portapapeles.

  - Patrón...: ... con un patrón determinado.

  - Datos aleatorios...: ... con datos aleatorios.

  - Secuencia: ... con todos los bytes desde 0 a 255.

Archivo Exportar

  Exporta los bytes seleccionados a un archivo...

  - Valores: ... codificados como valores de bytes. Por omisión, los valores se separan con un espacio en blanco. Los caracteres de separación se pueden cambiar en el diálogo de Exportar.

  - Caracteres: ... codificados como texto sin formato.

  - Base64: ... codificado en formato Base64.

  - Base32: ... codificado en formato Base32.

  - Ascii85: codificado en formato Ascii85.

  - Uuencode: ... codificado en formato Uuencode.

  - Xxencoding: ... codificado en formato Xxencoding.

  - Intel Hex: ... codificado en formato Intel Hex.

  - S-Record: ... codificado en formato S-Record.

  - Array de C: ... definido como un array en el lenguaje de programación C.

  - Ver en texto plano: ... como en la vista de datos con desplazamiento, muestra valores de bytes y caracteres.

Archivo Permisos Asignar solo lectura

  Cuando está activado, no se podrán hacer cambios en la tabla de bytes cargada.

Archivo Cerrar los demás

  Cierra todos los arrays de bytes, excepto el actual.

#### El menú Editar

Copiar y cortar envían datos al portapapeles con el tipo MIME «application/octetstream». &klipper; no es capaz de mostrar este tipo de datos. Casi ninguna otra aplicación podrá manejarlos, ya que solo son datos sin formato. Vea también el submenú Copiar como.

Edición Copiar como

  Copiar los bytes seleccionados en uno de los distintos formatos en el portapapeles. Para obtener una de los formatos disponibles, consulte la opción del menú Archivo Exportar

Edición Insertar
  Insertar patrón...

    Inserta una cadena específica de bytes en la posición del cursor.

    Las opciones del diálogo le permiten especificar el número de veces que se insertará el patrón y su formato (Hexadecimal, Decimal, Octal, Binario, Caracteres o UTF-8).

&Ctrl;&Shift;A Editar Deseleccionar

  Deselecciona la selección actual.

&Ctrl;E Editar Seleccionar intervalo...

  Abre un diálogo empotrado para introducir el intervalo a seleccionar.

Ins Edición Modo de sobrescritura

  Cambia entre el modo Insertar y el modo Sobrescribir.

  La implementación del modo de sobrescritura es muy estricta, ya que no es posible cambiar el tamaño de los datos (no se puede añadir ni eliminar bytes).

&Ctrl;F Edición Encontrar...

  Encuentra un patrón específico en el documento. Pueden ser buscados patrones hexadecimales, decimales, octales, binarios o texto.

  Las opciones en el cuadro de diálogo le permiten especificar el punto de inicio, la dirección y el rango de la búsqueda.

&Ctrl;G Edición Ir al desplazamiento...

  Mueve el cursor hacia un desplazamiento específico.

#### El menú Ver

F11 Ver Mostrar desplazamientos de líneas

  Cambia entre sí/no la visualización en un panel de la línea de desplazamiento a la izquierda.

Vista Mostrar valores o caracteres

  Selecciona las interpretaciones de los bytes que se mostrarán. Las posibles son:

  - Valores

  - Caracteres

  - Valores y caracteres

Vista Codificación de los valores

  Selecciona la codificación de los valores entre:

  - Hexadecimal

  - Decimal

  - Octal

  - Binario

Vista Codificación de caracteres

  Selecciona la codificación de los caracteres en el submenú.

Vista Mostrar caracteres no imprimibles

  Cambia entre sí/no la visualización de los caracteres no imprimibles Si se encuentra apagado, en los lugares correspondientes de la columna de caracteres se mostrará en su lugar un carácter sustituto.

Vista Fijar bytes por línea

  Selecciona los bytes seleccionados por línea en el diálogo. El valor por omisión es de 16 bytes.

Vista Fijar bytes por grupo

  Por omisión, los valores hexadecimales se muestran en grupos de 4 bytes. Usando esta opción, puede adaptar este comportamiento según sus propias preferencias.

Ver Disposición dinámica

  Configura las reglas de diseño de la visualización de los datos. Esto define cuantos bytes son mostrados en pantalla por línea, dependiendo del ancho de la vista. Las reglas posibles son:

  - Desactivada: El diseño se adapta al número de bytes actual por línea, y no se adapta a los cambios de tamaño de la vista.

  - Envolver solo grupos completos de bytes: Coloca tantos bytes por línea como sea posible, hasta que el grupo de bytes se encuentre completo.

  - Activada: Lo mismo que el anterior, pero permite también grupos incompletos de bytes.

Vista Modo de vista

  Selecciona la organización de las vista entre:

  - Columnas: Las interpretaciones de los valores y de los caracteres se muestran con la distribución clásica de cada uno de ellos en una columna separada.

  - Filas: La interpretación en caracteres de un byte se muestra directamente debajo de la interpretación del valor.

&Ctrl;&Shift;T Ver Dividir horizontalmente

  Divide el área de la vista enfocada actualmente en dos partes, añadiendo una copia de la vista actual a la nueva área inferior.

&Ctrl;&Shift;L Ver Dividir verticalmente

  Divide el área de la vista enfocada actualmente en dos partes, añadiendo una copia de la vista actual a la nueva área de la derecha.

&Ctrl;&Shift;R Ver Cerrar el área de visión

  Cierra el área de visión con la vista enfocada actualmente.

Ver Perfil de vista

  Las preferencias de la vista se pueden guardar de forma separada en perfiles de vista. El perfil seleccionado en la actualidad se puede actualizar directamente desde las preferencias de la vista actual, o bien puede crear uno nuevo a partir de ellas. Todos los perfiles de vista se pueden gestionar en un diálogo al que puede acceder usando Preferencias Gestionar perfiles de la vista....

#### El menú Ventana

Proporciona un listado de las vistas actuales. Selecciona la ventana activa.

#### El menú Marcadores

Es posible establecer diversos marcadores para una única tabla de bytes. Cada tabla de bytes tiene su propio conjunto de marcadores, y el apropiado se muestra al final del menú Marcadores. Elija un marcador en el menú para desplazar el cursor y la vista hasta él.

Los marcadores son temporales en la actualidad y no se guardan si cierra el array de bytes o el programa.

&Ctrl;B Marcadores Añadir marcador

  Marca una posición dentro de la tabla de bytes.

&Ctrl;&Shift;B Marcadores Borrar marcador

  Borra el marcador actual. Esta orden se encuentra disponible si el cursor está en una posición marcada.

Marcadores Borrar todos los marcadores

  Limpia el listado de los marcadores.

&Alt;Flecha hacia arriba Marcadores Ir al marcador anterior

  Mueve el cursor al marcador anterior.

&Alt;Flecha abajo Marcadores Ir al marcador siguiente

  Mueve el cursor al siguiente marcador.

#### El menú Herramientas

Proporciona un listado de las herramientas instaladas. Activa o desactiva la visualización de cada herramienta. Puede encontrar una descripción detallada de cada herramienta en la sección Herramientas.

#### El menú Preferencias

Preferencias Gestionar perfiles de vistas...

  Abrir un diálogo para crear, editar, borrar y asignar un perfil de vista por omisión.

## Créditos y licencia

&okteta;

Copyright del programa 2006-2012 &Friedrich.Kossebau; &Friedrich.Kossebau.email;

Copyright de la documentación 2008,2010 &Friedrich.Kossebau; &Friedrich.Kossebau.email;, &Alex.Richardson; &Alex.Richardson.email;

Traducido por Ignacio Poggi ignaciop.3@gmail.com

&underFDL; &underGPL;

&documentation.index;