Quelle est la façon recommandée d'implémenter le défilement de texte dans les ncurses?

NCurses ne connaît que l'écran actuel. Lorsque l'écran est défilé, les ncurses ne gardent pas de trace d'un texte qui quitte l'écran. Votre terminal peut avoir un tampon de retour de défilement mais qui est indépendant des ncurses et des malédictions n'a aucune visibilité dans la mémoire tampon de défilement du terminal.

Je pense que vous devriez garder une trace de votre position actuelle dans le fichier si vous devez faire défiler.

Je n'ai pas pensé que les ncurses ont fait word work comment allez-vous le mot wrap?

Je ne suis pas encore très expérimenté dans les ncurses, donc je ne connais donc pas toutes les fonctions de la bibliothèque, mais la conservation de la liste de lignes de texte doublement liée pourrait fonctionner. Voici un clone primitif de moins:

#include <ncurses.h>
#include <stdlib.h>

#define MAXLEN 128

typedef struct Line {
    char contents[MAXLEN];
    struct Line *prev, *next;
} Line;

Line *head, *curr;

int nr_lines;
int curr_line;

int term_rows, term_cols;

void load(const char *filename);
void draw(Line *l);

int main(int argc, char **argv)
{
    if (argc == 1)
    {
        fputs("less: No file to open\n", stderr);
        return 1;
    }

    initscr();
    noecho();
    keypad(stdscr, TRUE);   // for KEY_UP, KEY_DOWN
    getmaxyx(stdscr, term_rows, term_cols);
    addstr("Reading text...\n");

    load(argv[1]);

    curr = head;
    curr_line = 0;
    draw(curr);

    int ch;
    while ((ch = getch()) != EOF && ch != 'q')
    {
        if (ch == KEY_UP && curr->prev != NULL)
        {
            curr_line--;
            curr = curr->prev;
        }
        else if (ch == KEY_DOWN && curr->next != NULL
            && curr_line + term_rows < nr_lines)
        {
            curr_line++;
            curr = curr->next;
        }
        draw(curr);
    }

    endwin();
    return 0;
}

void load(const char *filename)
{
    FILE *fp = fopen(filename, "r");
    Line *lp;

    head = malloc(sizeof(Line));
    head->prev = head->next = NULL;
    curr = head;

    while (fgets(curr->contents, MAXLEN, fp))
    {
        lp = malloc(sizeof(Line));
        lp->prev = curr;
        curr->next = lp;
        curr = lp;
        nr_lines++;
    }
    curr->next = NULL;
}

void draw(Line *l)
{
    int i;
    clear();
    for (i = 0; i < term_rows && l != NULL; i++, l = l->next)
        addstr(l->contents);
}

La réponse dépend de la quantité de texte que vous avez et quelles autres utilisations que vous apportez des données sur l'écran. Mais généralement le pad est préférable façon d'afficher du texte défilé. Ce n'est pas seulement une fonctionnalité NCurses , mais est prise en charge par la plupart des mises en œuvre de malédictions (c'est-à-dire quoi que ce soit après la fin des années 1980).

A PAD est comme une fenêtre, mais sa taille ne se limite pas à la taille de l'écran actuelle. Au lieu de cela, les données sont montrées à travers une vue dont la position dans le bloc-coussinet peut être facilement modifiée.

Il existe deux exemples de programmes dans NCurses-Exemples qui sont pertinents: vue.c affiche un fichier en écrivant son contenu sur une fenêtre, tandis que padview.c utilise un pad sur lequel le fichier entier est dessiné et utilise le pad -fonctions pour déplacer la vue autour du besoin, haut / bas et gauche / droite.

Dans ces programmes, la fonction show_all est le dessin actuel et est environ un troisième à long terme pour padview.c (35 lignes) par rapport à l'équivalent pour View.c (94 lignes).

En plus de lecture: Discussion sur Voir à titre d'exemple pour comparer les bibliothèques NCurses et SLANG.