Como abstrair a partir de uma exibição?

5

Estou construindo um editor de texto embutido que consiste em um teclado, um monitor LCD e um microcontrolador PIC32, a ser programado em C. O aplicativo deve parecer, por exemplo, como o editor GNU nano . O display tem 40x16 caracteres.

Atualmente estou me perguntando o que seria uma boa abstração da exibição. Poderíamos conceituar um terminal simples da seguinte forma:

typedef struct {
    char* content;              // Current and past content
    void (*update)(Terminal);   // Update function
} Terminal;
void append(Terminal, char*);   // Append to content & execute update function
void discard(Terminal, int);    // Discard last n characters & execute update f.

Ao adicionar um ponteiro de função ao tipo Terminal , basicamente temos um modelo e uma visualização. O Terminal pode ser controlado pelas funções append() e discard() . Com esse Terminal , poderíamos criar um terminal simples com stdin e stdout .

No entanto, isso não é suficiente para um editor de nano -like, onde o texto pode ser inserido e removido em qualquer lugar da tela, não apenas no final dos dados atuais.

Eu criei agora o seguinte tipo:

typedef struct {
    unsigned short rows, columns,     // Screen size
            first_visible_row, first_visible_column,  // Left-top coordinates
            cursor_x, cursor_y;       // Cursor coordinates
    char* content;                    // Current and off-screen content
    void (*update)(Screen);           // Update function
} Screen;

Esse Screen também mantém conteúdo fora da tela, e sua seção visível é determinada por suas coordenadas superiores esquerdas. Isso facilita a rolagem. Mas, as funções para gravar nessa tela em alguma posição seriam complicadas, porque não há relação direta entre uma posição em content e suas coordenadas na exibição real.

Uma maneira mais fácil de trabalhar com o tipo seria manter uma matriz de rows char arrays, para linhas diferentes na tela. Então, content seria uma matriz de matrizes de caracteres, ou seja, char** content .

Basicamente, estou perguntando se há problemas com minha abordagem sugerida e se há uma abordagem mais fácil .

Para resumir, aqui estão alguns dos requisitos para a tela:

  • Deve ser fácil rolar em
  • Deve ser possível adicionar e remover texto em qualquer ponto da tela
por Keelan 19.08.2015 / 17:19
fonte

2 respostas

1

Você pode se beneficiar de um conceito de buffer duplo, no qual armazena linhas maiores que a exibição em uma estrutura maior e uma matriz ampliada de 40 * 16 que pode se mover para cima ou para baixo com eventos de exibição. Forneça ponteiros de deslocamento para cada início de linha e o final é determinado para que as setas se movam ao redor da área maior. Limite de deslocamento para min max. Em seguida, cortar e colar é cópia de segmento de linha por linha. Cópias da área de múltiplas linhas seriam as mais difíceis de rastrear, você poderia limitar a janela para começar.

A área do buffer dentro e fora do arquivo é uma única gravação no final das operações.

A exibição é uma operação personalizada por cadeia de caracteres.

    
por 29.09.2015 / 03:16
fonte
0

É uma boa ideia ter um conteúdo representado como char* , porque é isso que é conceitualmente.

char** é ruim como modelo de conteúdo, porque está vinculado a um tamanho de tela e tamanho de linha fixos. Por isso, só faz sentido como um 'modelo de visualização' da tela.

Quanto às relações entre as coordenadas do cursor e a posição na matriz de conteúdo, vejo duas opções que devem funcionar bem:

  • tem uma função que calcula um índice no conteúdo com base nas coordenadas atuais do cursor e na posição da tela (não vejo por que seria muito difícil)

  • mantém uma matriz bidimensional de índices em conteúdo, onde cada elemento corresponde a uma possível posição do cursor; ele precisará ser atualizado em todas as atualizações da tela

por 05.09.2015 / 06:32
fonte