C > ncurses

Lors de la compilation avec gcc, il faut spécifier la bibliothèque Ncurses et pour cela il vous faut rajouter l’option lncurses.

gcc -lncurses -o toto toto.c

 

Si problème d’affichage apres un script : Créer un fichier nommé sos, lequel vous restaurera les paramètres d’origine de la console. Il suffit d’y mettre :

#!/bin/sh
stty -raw <># Réutilise le mode RAW pour l'interception des signaux et autres
stty echo <># Remise en place de l'echo
stty onlcr <># Remise en place du retour chariot

 

chmod +x sos

Ainsi vous n’aurez plus qu’a taper sos dans votre console pour effacer les effets dûs à de mauvaises manipulations.

Hello world

HelloWorld.c

#include <ncurses.h>

int main(void)
{
    initscr();              // Initialise la structure WINDOW et autres paramètres
    printw("Hello World");  // Écrit Hello World à l'endroit où le curseur logique est positionné
    refresh();              // Rafraîchit la fenêtre courante afin de voir le message apparaître
    getch();                // On attend que l'utilisateur appui sur une touche pour quitter
    endwin();               // Restaure les paramètres par défaut du terminal

    return 0;
}

Avec ncurses.h, il n’y a plus besoin d’inclure stdio.h car incluse dans ncurses.h

Se positionner dans la fenêtre

La fonction move déplace le curseur à l’endroit voulu

#include <ncurses.h>

int main(void) {
    initscr();
    move(LINES - 1, COLS - 1);  // Déplace le curseur tout en bas à droite de l'écran
    addch('.');                 // Écrit le caractère . au nouvel emplacement

    mvaddch(LINES - 1, COLS - 1, '.');  // équivalent aux deux lignes ci-dessus
    mvprintw(LINES - 1, COLS - 1, "."); // idem

    getch();
    endwin();

    return 0;
}

LINES et COLS représentent le nombre de lignes et colonnes du terminal actuel. Après redimensionnement, ces deux variables sont mises à jour.

La fonction mvFonction a plusieurs fonctions, comme par exemple, mvaddstr, etc. Voir le man correspondantes.

mises en forme

Normal (A_NORMAL)

Surlignement (A_STANDOUT)

Inversion vidéo (A_REVERSE)

Atténué (A_DIM)

Brillant ou gras (A_BOLD)

Souligné (A_UNDERLINE)

Mode invisible ou blanc (A_INVIS)

attron/attroff applique/annule les mises en forme. A_NORMAL permet d’annuler toutes les mises en forme appliquées.

#include <ncurses.h>

int main(void)
{
    initscr();

    attron(A_NORMAL);
    printw("Texte sans mise en forme\n");

    attron(A_STANDOUT);
    printw("Texte en meilleur surlignement\n");
    attroff(A_STANDOUT);

    attron(A_REVERSE);
    printw("Texte en inversion video\n");
    attroff(A_REVERSE);

    attron(A_DIM);
    printw("Texte a moitie brillant\n");
    attroff(A_DIM);

    attron(A_BOLD);
    printw("Texte en gras\n");
    attroff(A_BOLD);

    attron(A_UNDERLINE);
    printw("Texte en souligne\n");
    attroff(A_UNDERLINE);

    attron(A_INVIS);
    printw("Texte invisible\n");
    attroff(A_INVIS);

    attron(A_UNDERLINE | A_BOLD); // Pour plusieurs type de mises en forme, on utilise |
    printw("Texte en gras souligne\n");

    attron(A_NORMAL);
    refresh();
    getch();
    endwin();

    return 0;
}

Pour une mise en forme commune pour chaque fenêtre, plutôt que d’utiliser attron à chaque fois, on peut utiliser attrset. Ainsi, n’importe qu’elle fenêtre créée héritera de cet attribut et donc chaque fois que vous écrirez dedans, ça sera automatiquement mis en gras.

Lire une chaîne de caractères à partir du clavier

il existe des fonctions vous permettant de lire des chaînes de caractères d’une seule traite sans avoir à passer par la méthode getch utilisée jusqu’à présent.

Cette méthode se nomme getstr et permet donc de lire une chaîne entière de caractères. Voyons maintenant comment s’en servir.

Créer plusieurs fenêtres

subwin . Il suffit juste de dire quelle est la fenêtre à diviser ainsi que les dimensions voulues. Une fois fait, une nouvelle sous-fenêtre sera retournée (de type WINDOW *).

#include <ncurses.h>

int main(void) {
    WINDOW *haut, *bas;

    initscr();
    haut= subwin(stdscr, LINES / 2, COLS, 0, 0);        // Créé une fenêtre de 'LINES / 2' lignes et de COLS colonnes en 0, 0
    bas= subwin(stdscr, LINES / 2, COLS, LINES / 2, 0); // Créé la même fenêtre que ci-dessus sauf que les coordonnées changent

    box(haut, ACS_VLINE, ACS_HLINE);
    box(bas, ACS_VLINE, ACS_HLINE);

    mvwprintw(haut, 1, 1, "Ceci est la fenetre du haut");
    mvwprintw(bas, 1, 1, "Ceci est la fenetre du bas");

    wrefresh(haut);
    wrefresh(bas);

    getch();
    endwin();

    free(haut);
    free(bas);

    return 0;
}

Ne vous attardez pas sur la fonction box, elle sera détaillée juste après. Je l’ai juste utilisée pour vous montrer la taille des fenêtres que j’ai créées.

Créer une bordure autour de la fenêtre

Pour créer une bordure autour d’une zone définie, utiliser la fonction box sur une fenêtre (de type WINDOW *). Deux méthodes sont possibles :

La première consiste à créer une "boîte" avec les bordures par défaut (que l’on peut choisir parmi plusieurs types de bordures prédéfinies).

La seconde consiste à définir soit même quel caractère sera sur la ligne du haut, du bas, dans les coins, etc.

Méthode box

#include <ncurses.h>

int main(void) {
    WINDOW *boite;

    initscr();
    boite= subwin(stdscr, 10, 10, LINES / 2, COLS /2);

    box(boite, ACS_VLINE, ACS_HLINE); // ACS_VLINE et ACS_HLINE sont des constantes qui génèrent des bordures par défaut
    refresh();

    getch();
    endwin();

    free(boite);

    return 0;
}

Reportez vous aux pages man pour voir les différentes bordures disponibles (comme ACS_VLINE et ACS_HLINE par exemple).

Méthode wborder

#include <ncurses.h>

int main(void) {
    WINDOW *boite;

    initscr();
    boite= subwin(stdscr, 10, 10, LINES / 2, COLS /2);
    wborder(boite, '|', '|', '-', '-', '+', '+', '+', '+');
    wrefresh(boite);

    getch();
    endwin();

    free(boite);

    return 0;
}

Avec wborder, les deux premiers arguments après le pointeur de WINDOW que l’on passe en paramètre représentent respectivement les côtés gauche et droite, les deux suivants les côtés haut et bas et enfin les quatre derniers représentent les quatre coins de la bordure (haut gauche, haut droit, bas gauche, bas droit).

Centrer le texte

Avec les variables LINES et COLS générées par Ncurses. Ainsi, même si nous redimensionnons une fenêtre, le texte sera toujours centré. Attention cependant, lorsque vous redimensionner le terminal, c’est comme si une touche du clavier était appuyé.

#include <ncurses.h>

int main(void) {
    WINDOW *boite;

    initscr();
    printw("Le terminal actuel comporte %d lignes et %d colonnes\n", LINES, COLS);
    refresh();
    getch();
    endwin(); 

    free(boite);

    return 0;
}

Lorsque vous exécutez ce code et que vous tentez de redimensionner votre terminal, l’application s’arrête instantanément. Pour pallier à ce problème, nous utiliserons une boucle. Le code devient donc :

#include <ncurses.h>

int main(void) {
    WINDOW *boite;

    initscr();
    while(1) {
        printw("Le terminal actuel comporte %d lignes et %d colonnes\n", LINES, COLS);
        refresh();  // Rafraîchit la fenêtre par défaut (stdscr) afin d'afficher le message
        if(getch() != 410)  // 410 est le code de la touche générée lorsqu'on redimensionne le terminal
            break;
    }

    endwin();

    free(boite);

    return 0;
}

les variables LINES et COLS sont mises à jour lors de chaque évènement.

Maintenant venons au fait, pour centrer un texte, il suffit de partir du centre de la fenêtre, auquel on enlève la moitié de la longueur de notre texte :

#include <ncurses.h>
#include <string.h>

int main(void) {
    WINDOW *boite;
    char *msg= "Texte au centre";
    int taille= strlen(msg);

    initscr();
    while(1) {
        clear();    // Efface la fenêtre (donc l'ancien message)
        mvprintw(LINES/2, (COLS / 2) - (taille / 2), msg);
        refresh();
        if(getch() != 410)
            break;
    }

    endwin();

    free(boite);

    return 0;
}

il en va de même pour centrer une fenêtre ou tout autre composant.