# O Manual do &okteta;

Friedrich W. H. Kossebau

    &Friedrich.Kossebau.email;

Alex Richardson

    &Alex.Richardson.email;

José Pires

    zepires@gmail.com

Tradução
2008, 2010, 2011 &Friedrich.Kossebau; e &Alex.Richardson;
&FDLNotice;
2018-03-23
&okteta; 0.24.60

o &okteta; é um editor simples para os dados em bruto dos ficheiros. Este tipo de programas também se chama de editor hexadecimal ou editor binário.

KDE Okteta vista editar bits bytes binário octal hexadecimal editor hexadecimal dados em bruto

## Introdução

o &okteta; é um editor simples para os dados em bruto dos ficheiros.

Os dados são apresentados em duas variantes: como valores numéricos dos 'bytes' ou como os caracteres associados aos valores. Os valores e os caracteres poderão tanto ser apresentados separados em duas colunas como a seguir um aos outro, tendo o valor por cima do carácter. Do lado esquerdo, aparece a posição do primeiro 'byte' de cada linha. A edição poderá ser feita tanto nos valores como nos caracteres.

Para além das funcionalidades normais de edição, o &okteta; também oferece um pequeno conjunto de ferramentas, como uma descodificação da listagem em tabela para tipos de dados comuns, uma tabela que apresenta todos os 'bytes' possíveis em conjunto com os seus equivalentes em valor e em caracteres, uma área de informação com estatísticas, uma calculadora de códigos de validação, uma ferramenta de filtragem e uma ferramenta de extracção de textos.

Todas as modificações feitas aos dados carregados poderão ser desfeitas ou refeitas sem limites.

## Noções Básicas

### Iniciar o &okteta;

Escreva ``okteta`` numa linha de comandos ou seleccione o Editor Hexadecimal do grupo Aplicações Utilitários do lançador de aplicações.

Estão disponíveis as opções normais do &Qt; e do &kf5-full;, podendo apresentá-las se indicar ``okteta` `--help``.

As opções específicas da linha de comandos para o &okteta; são:

`<&URL;(s)>` - abre os ficheiros com os &URL;'s indicados

### Utilização

A janela principal do &okteta; tem as seguintes componentes: a barra do menu, a barra de ferramentas, a barra de estado, as áreas de dados separadas por páginas e uma ou mais barras laterais com as ferramentas.

Quando é aberto um ficheiro ou é criada uma sequência de 'bytes', os 'bytes' nela contidos são apresentados consecutivamente por linhas, tendo cada uma um dado número de 'bytes'. Estas são apresentadas em duas variantes: como valores numéricos dos 'bytes' ou como os caracteres associados aos valores. Os valores e os caracteres poderão tanto ser apresentados separados em duas colunas como a seguir um aos outro, tendo o valor por cima do carácter. Do lado esquerdo, aparece a posição do primeiro 'byte' de cada linha.

O tratamento é semelhante ao dos editores de texto: os dados poderão ser editados, cortados, copiados, colados, arrastados e largados, como acontece num editor de texto. Existe um cursor que marca a posição actual. Se carregar na tecla Insert, poderá alternar entre os modos de sobreposição e inserção. O modo de sobreposição é mais restrito que nos editores de texto, dado que não permite nenhuma operação que altere o tamanho da sequência de 'bytes'.

Ao contrário dos editores de texto, o conteúdo aparece em duas variantes. Só uma destas está activa no que respeita à introdução de dados. Existem dois cursores associados, presentes para o valor e para o carácter, sendo o cursor activo o que está intermitente. Com os caracteres activos, poderá introduzir caracteres como faz num editor de texto normal. Com os valores activos, ao escrever um número irá aparecer um editor mínimo para introduzir o resto do valor.

A janela de pesquisa permite ao utilizador procurar uma sequência específica de 'bytes', definida como valores (hexadecimal, decimal, octal, binário) ou texto (de momento, na codificação de 8 'bits', ou UTF-8).

Poderá abrir várias sequências de 'bytes' ao mesmo tempo, mas só poderá ter uma activa. Use o menu Janelas para seleccionar a sequência de 'bytes' que está activa.

## Ferramentas

### Introdução

O &okteta; traz algumas ferramentas, algumas delas para analisar e manipular as sequências de 'bytes' e outras com fins mais gerais. Estas ferramentas poderão ser activadas ou desactivadas com o item Ferramentas do menu. Cada ferramenta tem uma área pequena que se associa a uma das barras laterais ou que flui livremente como uma janela. Poderá acoplar, desacoplar, reorganizar e também empilhar as áreas de ferramentas com o rato, carregando com o &LMB; na barra de título de uma área de ferramentas, movendo-o à sua maneira e largando o &LMB; para completar a acção, caso contrário cancele-o com a tecla &Esc;.

#### Analisadores e Manipuladores

Tabela de Valores/Caracteres

  A tabela apresenta todos os valores possíveis de um 'byte', quer em diversas formas numéricas quer na forma de caracteres.

  O valor seleccionado poderá ser introduzido na posição do cursor, repetida numa determinada quantidade de vezes. Isto poderá ser obtido se usar o botão Inserir ou se fizer duplo-click na linha da tabela.

Filtro Binário

  O filtro efectua operações binárias sobre os 'bytes' seleccionados. Depois de escolher a operação (E, OU, RODAR...), poderá definir os parâmetros, se necessário, na área abaixo. O filtro é executado quando usar o botão Filtro.

Cadeias de caracteres

  Esta ferramenta localiza os pedaços de texto nos 'bytes' seleccionados. Depois de escolher o tamanho mínimo do texto, estes pedaços são pesquisados, bastando para tal usar o botão Extrair. A lista de textos apresentados poderá ser refinada se indicar um termo de filtragem.

Estatísticas

  A janela mostra alguma informação sobre a sequência de 'bytes'. Para além do tamanho, esta é uma estatística da frequência com que ocorre o valor de um determinado 'byte' na sequência. Toda a informação poderá ser calculada ao usar o botão para Construir.

Código

  O filtro efectua operações binárias sobre os 'bytes' seleccionados. Depois de escolher a operação e definir os parâmetros, se necessário, na área abaixo, o somatório é calculado quando usar o botão Calcular.

Tabela de Descodificação

  A tabela apresenta o valor do 'byte' ou 'bytes' que começam no cursor, interpretado como um tipo de dados simples, como o Inteiro ou Real, mas também como UTF-8. Se fizer duplo-click sobre uma linha da tabela, irá abrir um editor, de modo que o valor possa ser editado e alterado.

Estruturas

  Esta ferramenta activa a investigação e edição das sequências de 'bytes', baseando-se nas definições de estruturas criadas pelo utilizador. As instruções detalhadas sobre isto estão na sua própria secção.

#### Ferramentas gerais

Sistema de Ficheiros

  Esta ferramenta oferece um navegador de ficheiros incorporado que poderá usar para seleccionar os ficheiros a abrir.

Documentos

  Esta ferramenta mostra todos os ficheiros carregados ou criados neste momento. Os símbolos marcam o ficheiro com a área activa e também mostram os ficheiros que têm alterações por gravar ou qual a cópia armazenada que foi modificada por outro programa.

Favoritos

  Esta ferramenta poderá ser usada para gerir os favoritos, como alternativa ao menu Favoritos.

  Os favoritos são neste momento transitórios e não são gravados quando fechar uma lista de 'bytes' ou o programa por inteiro.

Informações do Ficheiro

  A área mostra algumas informações sobre o ficheiro actual, incluindo o seu tipo, a localização do armazenamento e o tamanho.

Terminal

  Um terminal incorporado, onde a pasta de trabalho não está associada ao ficheiro activo.

Conversão de Codificações

  A ferramenta volta a escrever os 'bytes' de forma a que os caracteres respectivos sejam os mesmos na outra codificação. Só são suportadas as codificações de 8 'bits', sendo que os caracteres sem correspondência são neste momento substituídos pelo valor fixo 0.

### Ferramenta de Estruturas

#### Geral

A ferramenta de Estruturas permite a análise e edição de sequências de 'bytes' com base na definição de estruturas criadas pelo utilizador, as quais poderão ser compostas por listas, uniões, tipos primitivos e enumerados.

Tem uma janela de configuração própria, que poderá ser acedida com o botão Configuração. Existem várias opções que poderão ser configuradas, como o estilo (decimal, hexadecimal ou binário) no qual são apresentados os valores. Para além disso, é possível escolher as definições de estruturas que são carregadas e quais são apresentadas na janela.

As estruturas são definidas nos ficheiros de Definição de Estruturas do &okteta; (baseados em &XML;, com a extensão `.osd`). Para além disso, um ficheiro `.desktop` contém os meta-dados acerca desse ficheiro de descrição de estruturas, como o autor, a página Web e a licença.

De momento, não existe nenhum suporte incorporado para criar ou editar as definições das estruturas, pelo que estas deverão ser criadas manualmente, como se encontra descrito nas secções seguintes.

#### Instalar as definições das estruturas

##### Instalar através do KNewStuff

A forma mais simples de instalar novas definições de estruturas é usar o suporte incorporado do KNewStuff no &okteta;. Para instalar uma estrutura existente, abra a janela de configuração da ferramenta de Estruturas. Aí, seleccione a página de Gestão de Estruturas e carregue no botão Obter Estruturas Novas.... A janela que aparecerá permite-lhe então instalar ou desinstalar estruturas.

##### Instalar manualmente as definições das estruturas

A ferramenta de Estruturas procura pelas descrições de estruturas na sub-pasta `okteta/structures/` da pasta do utilizador para os dados das aplicações (descubra-a com o comando ``qtpaths` `--path GenericDataLocation``). Poderá ter de criar esta pasta, caso não existam ainda nenhumas definições de estruturas instaladas.

Existem dois ficheiros para cada definição da estrutura: Um ficheiro para a definição em si e um ficheiro `.desktop` para os meta-dados (autor, versão, etc.).

Nessa sub-pasta, existe uma sub-pasta própria para cada definição de estruturas, a qual contém tanto o ficheiro `.desktop` como o `.osd` ou o `main.js` para essa definição.

Por exemplo, com a pasta de dados das aplicações ```qtpaths` `--paths GenericDataLocation``` e com uma definição de estrutura chamada EstruturaExemplo, existe a pasta `okteta/structures/EstruturaExemplo`, que contém um ficheiro `EstruturaExemplo.desktop` e um ficheiro `EstruturaExemplo.osd`.

##### Usar as estruturas acabadas de instalar

Se tiver instalado uma nova definição de estruturas, poderá ter de reiniciar o &okteta; e abrir a janela de configuração da ferramenta de Estruturas. Aí, seleccione a página de Gestão das Estruturas e certifique-se que a definição da estrutura relevante é assinalada. Depois, mude para a página Estruturas e certifique-se que o elemento desejado está listado no lado direito.

#### Partilhar definições de estruturas

Para as estruturas comuns, poderá não ter de criar você mesmo uma definição, mas sim reutilizar uma definição já existente de locais como o store.kde.org.

Poderá também querer partilhar você mesmo uma definição. Para o fazer, crie um pacote de ficheiros (⪚, um pacote tar.gz ou `.tgz`) contendo apenas a sub-pasta com o ficheiro `.desktop` e o ficheiro de definição da estrutura. No exemplo da última secção, seria a sub-pasta `EstruturaExemplo` com todo o seu conteúdo. Se usar este formato para partilhar as definições de estruturas, permite a instalação das mesmas dentro do &okteta; sem qualquer instalação manual.

#### Criar definições de estruturas

Poderá encontrar um guia mais actualizado, mas não completo, sobre a criação de definições de estruturas na Wiki de Base de Utilizadores do KDE.

Existem duas formas diferentes de criar definições de estruturas. O primeiro é criar a definição em &XML; e o outro é usando o JavaScript. A abordagem do JavaScript permite-lhe criar estruturas mais complexas com funcionalidades como p.ex. a validação da estrutura. A utilização do &XML; dá-lhe menos funcionalidades, mas se tudo o que precisar for uma estrutura estática, esta poderá ser a abordagem mais simples. Se necessitar de uma estrutura dinâmica, i.e., onde os tamanhos das listas dependem de outros valores na estrutura ou se a disposição da estrutura for diferente quando algum valor-membro mudar, então terá de criar a definição da estrutura em JavaScript. Existe uma excepção a essa regra: se tiver uma lista cujo tamanho é suposto ser exactamente igual a outro valor na estrutura, então poderá usar o &XML;. Contudo, se existir algo do tipo tamanho - 1, terá então de ser em JavaScript.

#### Formato do ficheiro &XML; de definição de estruturas

Poderá encontrar um guia mais actualizado, mas não completo, sobre a criação de definições de estruturas na Wiki de Base de Utilizadores do KDE.

O ficheiro &XML; `.osd` tem um elemento de raiz: o <data> sem quaisquer atributos. Dentro deste elemento, deverá existir um dos seguintes elementos:

<primitive>

  Para criar um tipo de dados primitivo como ⪚ o int e float. Este elemento não aceita sub-elementos e poderá ter os seguintes atributos:

  type

    O tipo primitivo em si. Deverá ser um dos seguintes:

    - char para um carácter ASCII a 8 bits

    - int8, int16, int32, int64 para um número inteiro com sinal do tamanho indicado

    - uint8, uint16, uint32, uint64 para um número inteiro sem sinal do tamanho indicado

    - bool8, bool16, bool32, bool64 para um valor boolean sem sinal (0 = falso, qualquer outro valor = verdadeiro) do tamanho indicado

    - float para um número de vírgula-flutuante IEEE754 a 32 bits

    - double para um número de vírgula-flutuante IEEE754 a 64 bits

<bitfield>

  Para criar um campo de 'bits'. Este elemento não aceita sub-elementos e poderá ter os seguintes atributos:

  width

    O número de 'bits' usados por este campo de 'bits'. Deverá ser entre 1 e 64.

  type

    O tipo deste campo de 'bits'. Deverá ser um dos seguintes:

    - unsigned para um campo de 'bits' em que o valor será interpretado como um valor sem sinal (com uma gama de 0 a 2width - 1)

    - signed para um campo de 'bits' em que o valor será interpretado como um valor com sinal (com uma gama de -2width - 1 a 2width - 1 - 1)

    - bool para um campo de 'bits' em que o valor será interpretado como booleano

    Lembre-se sempre de adicionar algum preenchimento a seguir a um <bitfield>, caso contrário o elemento seguinte (exceptuando as cadeias de caracteres e as listas, por adicionarem um preenchimento automático) irão começar a meio de um 'byte'. Obviamente, o preenchimento não é necessário se desejar este comportamento.

<enum>

  Para criar um tipo primitivo, mas em que os valores sejam apresentados como membros de uma enumeração, se possível. Este elemento não aceita sub-elementos (contudo, poderá necessitar de uma marca <enumDef> no ficheiro para a referenciar). Tem os seguintes atributos:

  enum

    O tipo enumerado subjacente deste valor. Deverá corresponder ao atributo name de uma das marcas <enumDef> neste ficheiro.

  type

    O tipo deste valor enumerado. Veja o atributo 'type' de <primitive>. A única diferença é que o Double e o Float não fazem aqui sentido.

<flags>

  Este é igual ao <enum>, com a única diferença em que os valores são representados como um OU-de-bits com todos os valores da enumeração.

<struct>

  Para criar uma estrutura. Todos os outros elementos (incluindo o próprio <struct>) poderão ser filhos deste e farão então parte da estrutura resultante

<union>

  Para criar uma união. Basicamente, é igual ao <struct>, com a diferença que todos os elementos-filhos começam na mesma posição. Útil para interpretar a mesma sequência de 'bytes' de várias formas.

<array>

  Para criar uma lista. Este elemento aceita exactamente um filho (o tipo inerente da lista), que poderá ser qualquer elemento, até mesmo o próprio <array>. Também tem os seguintes atributos:

  length

    O número de elementos desta lista, como um número decimal. Em alternativa, também poderá ser um texto que corresponda ao valor do atributo 'name' de um elemento <primitive>, <enum> ou <flags> previamente definido. Aí, o tamanho será o valor desse elemento. De momento, está limitado a 10000, porque as listas maiores irão usar demasiada memória e tornariam a ferramenta demasiado lenta.

<string>

  Para criar uma cadeia de caracteres com várias codificações. Por omissão, irá obter uma cadeia de caracteres terminada em NULL, como no C. Contudo, poderá criar vários tipos de cadeias de caracteres com os seguintes atributos:

  terminatedBy

    Este atributo define qual o código Unicode com que termina o texto. Deverá ser um número hexadecimal (opcionalmente com um 0x inicial). Quando a codificação for a ASCII, só fazem sentido valores até 0x7f. Se nem este valor nem os valores de maxCharCount ou maxByteCount estiverem definidos, assume-se como sendo 0 (como no C).

  maxCharCount

    O número máximo de caracteres que esta cadeia de caracteres poderá ter. Se o terminatedBy também estiver definido, então o que ocorrer primeiro corresponderá ao fim do texto. Isto é mutuamente exclusivo com o maxByteCount

  maxByteCount

    O número máximo de 'bytes' que este texto poderá ter de tamanho. Se o terminatedBy também estiver definido, então o que ocorrer primeiro irá definir o fim do texto. Isto é mutuamente exclusivo com o maxCharCount. Com as codificações como a ASCII, este valor é igual ao de maxCharCount.

  type

    A codificação desta cadeia de caracteres. Poderá ser um dos seguintes valores:

    - ASCII

    - LATIN-1

    - UTF-8

    - UTF-16-LE ou UTF-16-BE. Se nem o sufixo -LE nem o -BE forem indicados, assume-se o 'little endian'.

    - UTF-32-LE ou UTF-32-BE. Se nem o sufixo -LE nem o -BE forem indicados, assume-se o 'little endian'.

Todos os elementos aceitam também um atributo name que ficará visível na área de estruturas.

#### Uma definição de estrutura de exemplo tanto em &XML; como em JavaScript

Poderá encontrar um guia mais actualizado, mas não completo, sobre a criação de definições de estruturas na Wiki de Base de Utilizadores do KDE.

##### O passos comum, partilhado por ambas as abordagens

Os nossos meta-dados ficarão algo do género:

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

            Name=Estrutura de testes simples
            Comment=Uma estrutura muito simples de testes que só contém dois itens

            X-KDE-PluginInfo-Author=José Pires
            X-KDE-PluginInfo-Email=jose.pires@email.org
            X-KDE-PluginInfo-Name=estrutura-simples
            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

O ícone que aparece no &okteta; para esta estrutura poderá ser qualquer coisa devolvida pela execução de ``kdialog` `--geticon`` ou a localização de um ícone

Estes campos deverão ser relativamente intuitivos, exceptuando o `X-KDE-PluginInfo-Name`. O valor deste campo deverá corresponder ao nome da pasta que contém o ficheiro, assim como o nome do ficheiro `.desktop`. Ao criar as definições de estruturas em &XML;, o nome do ficheiro `.osd` deverá também corresponder ao nome.

Neste exemplo, teríamos uma pasta chamada `estruturasimples` que contém os ficheiros `estruturasimples.desktop`. Ao definir as estruturas em &XML;, a pasta iria conter também um ficheiro chamado `estruturasimples.osd`. Se usarmos o JavaScript, iríamos ter um ficheiro chamado `main.js` em alternativa.

##### Uma definição de estrutura simples em &XML;

Para começar, iremos criar uma definição de uma estrutura de testes muito simples, contendo apenas tipos de dados integrais (um carácter, um inteiro com sinal de 32 bits e um campo de bits). Isto seria descrito em C/C++ como:

              struct simples {
                char umCaracter;
                int umInteiro;
                bool campoBits :1;
                unsigned preenchimento :7;
              };

O primeiro passo é criar o ficheiro `.osd` de acordo com o formato do ficheiro definido na secção anterior. Iremos chamar ao ficheiro `estrutura-simples.osd`:

              <?xml version="1.0" encoding="UTF-8"?>
              <data>
                <struct name="simple">
                  <primitive name="umCaracter" type="Char"/>
                  <primitive name="umInteiro" type="Int32"/>
                  <bitfield name="campoBits" type="bool" width="1"/>
                  <bitfield name="preenchimento" type="unsigned" width="7"/>
                </struct>
              </data>

, o que corresponderá de certa forma à definição em C/C++.

Agora crie uma sub-pasta `estrutura-simples` como descrito acima, copie os dois ficheiros para esta pasta e reinicie o &okteta;, para poder usar a nova estrutura.

##### A estrutura simples em JavaScript

Para implementar a estrutura acima em JavaScript, crie um ficheiro chamado `main.js` em vez de `simplestruct.osd` e mude o texto 'X-KDE-PluginInfo-Category=structure' para 'X-KDE-PluginInfo-Category=structure'. O conteúdo desse ficheiro seria:

            function init() {
              var estrutura = struct({
                carácter : char(),
                inteiro : int32(),
                opcaoBit : bitfield("bool", 1),
                preenchimento : bitfield("unsigned", 7),
              })
              return estrutura;
            }

A estrutura apresentada pelo &okteta; é sempre o valor devolvido pela função `init`.

Poderá invocar as seguintes funções para criar um tipo primitivo:

- char()

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

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

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

- float()

- double()

A função 'bitfield' recebe dois parâmetros, sendo o primeiro um texto que consiste em `bool`, `signed` ou `unsigned`. O segundo parâmetro é um inteiro que define o tamanho em 'bits'.

##### Estruturas mais complexas

De seguida, iremos criar uma estrutura mais complexa, que se irá chamar "complexa" e gravá-la num ficheiro `complexa.osd`. Esta estrutura irá conter duas listas (uma de tamanho fixo e outra com o tamanho determinado durante a execução), assim como uma estrutura encadeada e uma união.

              <?xml version="1.0" encoding="UTF-8"?>
              <data>
                <struct name="complexa">
                  <primitive name="tamanho" type="UInt8" />
                  <union name="umaUniao">
                    <array name="quatroBytes" length="4">
                      <primitive type="Int8" />
                    </array>
                  </union>
                  <struct name="encadeado">
                    <array name="texto" length="tamanho"> <!-- referencia o campo 'tamanho' acima -->
                      <primitive type="Char" />
                    </array>
                  </struct>
                </struct>
              </data>

Isto irá corresponder ao seguinte, em pseudo-C/C++

    struct complexa {
                uint8_t tamanho;
                union umaUniao {
                  int8_t quatroBytes[4];
                };
                struct encadeado {
                  char texto[tamanho] //C++ não válido por referenciar o valor de 'tamanho'
                };
              };

Obviamente, só poderá ter campos de referência de listas de tamanho dinâmico antes da lista.

Depois, será criado o ficheiro `complexo.desktop`, como foi feito no exemplo anterior (certifique-se que define o `X-KDE-PluginInfo-Name` correctamente) e faça o mesmo para instalar ambos os ficheiros.

##### Mais informações

Poderá encontrar alguns exemplos de definições de estruturas aqui. Isto inclui, por exemplo, o cabeçalho dos ficheiros PNG. Poderá encontrar um esquema em &XML; que descreve a estrutura do ficheiro `.osd` aqui. Se precisar de mais informações, sinta-se à vontade em contactar-me em &Alex.Richardson.email;

## Apresentação à Interface

### Opções do Menu

Para além dos menus comuns do &kde;, descritos no capítulo do Menu dos Fundamentos do &kde;, o &okteta; tem estes itens de menu específicos da aplicação:

#### O Menu Ficheiro

&Ctrl;N Ficheiro Novo

  Cria uma nova sequência de 'bytes'...

  - Vazio: ... uma sequência vazia.

  - Da Área de Transferência: ... com o conteúdo actual da área de transferência.

  - Padrão...: ... com um dado padrão.

  - Dados Aleatórios...: ... com dados aleatórios.

  - Sequência: ... com todos os 'bytes' de 0 a 255.

Ficheiro Exportar

  Exporta os 'bytes' seleccionados para um ficheiro...

  - Valores: ... codificadores como valores de 'bytes'. Por omissão, os valores são separados por um espaço em branco. Os caracteres de Separação podem ser alterados na janela Exportar.

  - Caracteres: ... codificados como texto simples.

  - Base64: ... codificado no formato Base64.

  - Base32: ... codificado no formato Base32.

  - Ascii85: ... codificado no formato Ascii85.

  - Uuencoding: ... codificado no formato do Uuencode.

  - Xxencoding: ... codificado no formato do Xxencoding.

  - Hexadecimal da Intel: ... codificado no formato Hexadecimal da Intel.

  - Registo-S: ... codificado no formato de Registo-S.

  - Vector em C: ... definido como uma lista na linguagem de programação C.

  - Ver em Texto Simples: ... como na área de dados, com o deslocamento, os valores dos 'bytes' e os seus caracteres.

Ficheiro Permissões Colocar Apenas para Leitura

  Quando estiver definido, as alterações não poderão ser feitas na sequência de dados carregada.

Ficheiro Fechar Todos os Outros

  Fecha todas as sequências de 'bytes', excepto a actual.

#### O Menu Editar

A cópia e a colagem simples enviam os dados para a área de transferência com o tipo MIME application/octetstream; o &klipper; não é capaz de apresentar estes dados, assim como a maioria das outras aplicações, por estes serem dados em bruto. Veja também o submenu Copiar como.

Editar Copiar como

  Copia os 'bytes' seleccionados num dos diferentes formatos para a área de transferência. Para obter uma lista dos formatos disponíveis, veja o item do menu Ficheiro Exportar

Editar Inserir
  Inserir um Padrão...

    Insere uma sequência definida de 'bytes' na posição do cursor.

    As opções na janela permitem-lhe definir o número de inserções do padrão e o seu formato (Hexadecimal, Decimal, Octal, Binário ou Caracteres ou UTF-8).

&Ctrl;&Shift;A Editar Deseleccionar

  Desmarca a selecção actual.

&Ctrl;E Editar Seleccionar o Intervalo...

  Abre uma janela incorporada para definir o intervalo de selecção.

Ins Editar Modo de Sobreposição

  Comuta entre o modo de Inserção e o de Sobreposição.

  O modo de sobreposição está implementado de forma a ser bastante restrito; não é possível alterar o tamanho dos dados (não permite adicionar nem remover 'bytes').

&Ctrl;F Editar Procurar...

  Procura um padrão definido no documento. Poderá procurar padrões em hexadecimal, decimal, octal, binário ou texto.

  As opções da janela permitem-lhe definir o ponto inicial, a direcção e a gama da pesquisa.

&Ctrl;G Editar Ir para a Posição...

  Move o cursor para uma dada posição.

#### O Menu Ver

F11 Ver Mostrar a Posição da Linha

  Activa ou desactiva a apresentação da posição da linha numa área à esquerda.

Ver Mostrar os Valores ou Caracteres

  Seleccione qual das interpretações de 'bytes' que são apresentadas. Os valores possíveis são:

  - Valores

  - Caracteres

  - Valores e Caracteres

Ver Codificação do Valor

  Selecciona a codificação dos valores como sendo:

  - Hexadecimal

  - Decimal

  - Octal

  - Binário

Ver Codificação de Caracteres

  Selecciona a codificação dos caracteres no submenu.

Ver Mostrar os Caracteres Invisíveis

  Activa ou desactiva a apresentação dos caracteres invisíveis. Se a visualização estiver desactivada, no local correspondente da coluna de caracteres, é colocado um outro carácter de substituição.

Ver Definir os 'Bytes' por Linha

  Seleccione os 'bytes' apresentados por cada linha na janela; o valor por omissão é 16 'bytes'.

Ver Definir os 'Bytes' por Grupo

  Por omissão, os valores hexadecimais são apresentados em grupos de 4 'bytes'. Se usar este item do menu, poderá adaptar isto de acordo com as suas preferências numa janela.

Ver Disposição Dinâmica

  Define as regras de disposição da área de dados. Isto define quantos 'bytes' são apresentados por linha, dependendo da largura da janela. As regras possíveis são:

  - Desligado: A disposição é fixa para o número actual de 'bytes' por linha e não se adapta à alteração do tamanho da janela.

  - Repartir apenas os grupos de 'bytes' completos: Coloca o máximo de 'bytes' por linha possíveis, desde que fiquem grupos de 'bytes' completos.

  - Ligado: O mesmo que o anterior, só que permitindo também grupos incompletos de 'bytes'.

Ver Modo de Visualização

  Selecciona a disposição da janela como sendo:

  - Colunas: A interpretação dos valores e caracteres é apresentada na disposição clássica, com cada um deles apresentado numa coluna em separado.

  - Linhas: A interpretação em caracteres dos 'bytes' é apresentada directamente por baixo da interpretação do valor.

&Ctrl;&Shift;T Ver Dividir na Horizontal

  Divide a área de visualização actualmente em primeiro plano em duas partes, adicionando uma cópia da área actual à outra área por baixo.

&Ctrl;&Shift;L Ver Dividir na Vertical

  Divide a área de visualização actualmente em primeiro plano em duas partes, adicionando uma cópia da área actual à outra área à direita.

&Ctrl;&Shift;R Ver Fechar a Área de Visualização

  Fecha a área de visualização actualmente em primeiro plano.

Ver Perfil de Visualização

  As configurações de visualização poderão ser gravadas em separado como perfis de visualização. O perfil seleccionado de momento poderá ser actualizado directamente a partir da configuração actual ou poderá criar um novo a partir da mesma. Todos os perfis de visualização podem ser geridos numa janela que está disponível em Configuração Gerir os Perfis de Visualização....

#### O Menu Janelas

Oferece uma lista com as janelas actuais. Seleccione a janela activa.

#### O Menu Favoritos

Poderá definir vários favoritos para uma única sequência de 'bytes'. Cada sequência tem o seu próprio conjunto de favoritos, sendo o conjunto apropriado apresentado no fundo do Favoritos. Escolha um favorito do menu para mover o cursor e a janela para o mesmo.

Os favoritos são neste momento transitórios e não são gravados quando fechar uma lista de 'bytes' ou o programa por inteiro.

&Ctrl;B Favoritos Adicionar aos Favoritos

  Marca um determinado local na sequência de 'bytes'.

&Ctrl;&Shift;B Favoritos Remover o Favorito

  Remove o favorito actual. Este comando só está disponível se o cursor estiver num local marcado como favorito.

Favoritos Remover Todos os Favoritos

  Limpa a lista de favoritos.

&Alt;Cima Favoritos Ir para o Favorito Anterior

  Move o cursor para o favorito anterior.

&Alt;Baixo Favoritos Ir para o Favorito Seguinte

  Move o cursor para o favorito seguinte.

#### O Menu Ferramentas

Oferece uma lista com as ferramentas instaladas. Activa ou desactiva a apresentação de cada uma das ferramentas. Poderá ver uma descrição mais detalhada de cada ferramenta na secção Ferramentas.

#### O Menu Configuração

Configuração Gerir os Perfis de Visualização...

  Abre uma janela para criar, editar, apagar e definir um perfil de visualização predefinido.

## Créditos e Licença

&okteta;

Programa com 'copyright' 2006-2012 de &Friedrich.Kossebau; &Friedrich.Kossebau.email;

Documentação com 'Copyright' 2008,2010 de &Friedrich.Kossebau; &Friedrich.Kossebau.email;, &Alex.Richardson; &Alex.Richardson.email;

Tradução de José Nuno Pires zepires@gmail.com

&underFDL; &underGPL;
&documentation.index;