Introduzione alle ncurses, nuovi tipi e funzioni di base.

window - E' una rappresentazione contenente un'immagine di una parte di schermo.
screen - è una finestra con le dimensioni dell'intero schermo.
terminal - è uno screen speciale con informazioni riguardo all'aspetto dello schermo.

WINDOW *curscr - è una variabile che punta allo schermo corrente
WINDOW *stdscr - è una variabile che punta allo schermo di default
int LINES - è una variabile contenente il numero di linee che il terminale può visualizzare
int COLS - è una variabile contenente il numero di colonne che il terminale pò visualizzare

Al fine di compilare un programma creato con le ncurses, è necessario passare al linker attraverso gcc di linkare il programma alla libreria stessa.
Aggiungete quindi -lncurses come opzione di gcc quando compilate il vostro programma per evitare errori di linking.

Inizializzazione del terminale.

Per poter usare le funzioni di grafica delle ncurses, la prima funzione da chiamare è initscr() la quale inizializza tutte le strutture della libreria dopo aver determinato il tipo di terminale ecc. initscr() causa anche la cancellazione dello schermo ed il refresh.

Una volta terminato di usare le ncurses, potremo chiudere la libreria usando la funzione endwin()

Qualsiasi modifica si faccia allo schermo, non viene solitamente visualizzata finché non si fa l'update dello stesso, in questo modo si guadagna molta velocità ridisegnando lo schermo un'unica volta invece che ogni volta che lo si modifica. L'aggiornamento dello stesso può essere eseguito con la funzione refresh()

Le Finestre

Attraverso l'uso di finestre, il terminale può essere diviso in altri "sottoschermi" potendo così ottenere risultati ordinati e graficamente più soddisfacenti.

WINDOW *newwin(int nlines, int ncols, int begy, int begx)
Ha lo scopo di creare una nuova finestra dalle dimensioni indicate da nlines ed ncols, i quali indicano rispettivamente il numero di linee e colonne che la finestra deve avere. begy e begx indicano poi le coordinate a partire dall'angolo superiore sinistro ove la finestra va posizionata. newwin ritorna poi un puntatore alla nuova finestra creata che andrà salvato se si ha intenzione di poter fare ancora operazioni su detta finestra(scrittura, lettura, chiusura ecc.).

int delwin(WINDOW *win)
Distrugge la finestra win. Prima di distruggere una finestra è bene distruggere tutte le finestre che derivano da questa e prima di chiudere lo schermo con delwin() è bene distruggere tutte le finestre create.

int wrefresh(WINDOW *win)
Aggiorna il contenuto della finestra win

int mvwin(WINDOW *win, int y, int x)
Questa funzione permette di spostare la finestra win alle coordinate x e y.

WINDOW *subwin(WINDOW *orig, int nlines, int ncols, int begy, int begx)
Subwin ci permette di creare una sottofinestra di una finestra madre. orig indica la finestra madre a cui questa deve appartenere, nlines e ncols indicano il numero di linee e colonne che la finestra deve avere e begy, begx indicano la posizione della sottofinestra rispetto allo schermo. La funzione ci ritornerà un puntatore alla sottofinestra che andrà poi cancellata con delwin(WINDOW *subwin)

WINDOW *derwin(WINDOW *orig, int nlines, int ncols, int begy, int begx);
Questa funzione equivale a subwin, però le coordinate begx e begy sono relative all'angolo superiore sinistro della finestra orig che è la madre della sottofinestra creata.

int mvderwin(WINDOW *win, int par_y, int par_x)
Questa funzione ci permette di spostare una sottofinestra creata con derwin rispetto alle coordinate della finestra madre.

WINDOW *dupwin(WINDOW *win)
Come da nome dupplica una finestra ritornandoci un puntatore ad una nuova finestra identica all'originale.

int overlay(WINDOW *win1, WINDOW *win2)
Sovrascrive i punti in cui win1 coincide con win2, scrivendoci il testo di win1, senza però cancellare gli spazi vuoti. Possiamo dire che porta avanti di un piano win1 rispetto a win2 tenendo gli spazi vuoti (' ') come se fossero trasparenti.

int overwrite(WINDOW *win1, WINDOW *win2)
Uguale ad overlay, ma non considera gli spazi vuoti come trasparenti.

int copywin(WINDOW *win1, WINDOW *win2, int sminrow, int smincol, int dminrow, int dmincol, int dmaxrow, int dmaxcol, int overlay)
Copia win1 in un rettangolo di win2, sminrow e smincol indicano le coordinate dell'angolo superiore sinistro di win1, mentre dminrow, dmincol, dimaxrow e dmaxcol definiscono il rettangolo in win2. overlay definisce infine se la finestra deve essere copiata con il metodo di overlay ciò considerando gli spazi come trasparenti o no.

Funzioni di Output

int addch(ch)
int waddch(win, ch)
int mvaddch(y, x, ch)
int mvwaddch(win, y, x, ch)
Queste funzioni hanno lo scopo di inserire una carattere sullo schermo. addch e waddch lo aggiungono rispettivamente sullo schermo ed in una finestra alle coordinate correnti del cursore, mentre mvaddch e mvwaddch permettono di inserire il carattere in una posizione a nostra scelta.

int addstr(str)
int addnstr(str, n)
int waddstr(win, str)
int waddnstr(win, str, n)
int mvaddstr(y, x, str)
int mvaddnstr(y, x, str, n)
int mvwaddstr(win, y, x, str)
int mvwaddnstr(win, y, x, str, n)
Queste funzioni inseriscono invece una stringa sullo schermo od in una finestra. Come sempre le funzioni con prefisso MV indicano che la stringa può essere posizionata in coordinate passate alla funzione, quelle con W indicano che la stringa è inserita all'interno di una particolare finestra, e quelle contenenti N(tipo addnstr) inseriscono n caratteri della stringa soltanto

int addchstr(chstr)
int addchnstr(chstr, n)
int waddchstr(win, chstr)
int waddchnstr(win, chstr, n)
int mvaddchstr(y, x, chstr)
int mvaddchnstr(y, x, chstr, n)
int mvwaddchstr(win, y, x, chstr)
int mvwaddchnstr(win, y, x, chstr, n)
Queste funzioni sono simili a quelle della famiglia addstr, solo che non vanno a capo dopo aver scritto la stringa, non elidono i caratteri speciali quali \n, \t ecc. e se la stringa è più lunga del margine della finestra la tagliano invece di proseguirla a capo.

int echochar(ch)
int wechochar(win, ch)
Queste funzioni equivalgono ad addch e waddch, ma dopo la loro esecuzione viene chiamato rispettivamente refresh o wrefresh in automatico

int printw(fmt, ...)
int wprintw(win, fmt, ...)
int mvprintw(y, x, fmt, ...)
int mvwprintw(win, y, x, fmt, ...)
int vwprintw(win, fmt, ...)
Questo set di funzioni si occupa di gestire l'output formattato in maniera del tutto identica a printf.

int insch(c)
int winsch(win, c)
int mvinsch(y,x,c)
int mvwinsch(win,y,x,c)
Queste funzioni inseriscono un carattere o nella posizione corrente del cursore o in posizione x,y spostando avanti tutti i caratteri che seguono.

int insertln()
int winsertln(win)
Inseriscono una linea vuota prima di quella corrente

int insdelln(n)
int winsdelln(win, n)
Con n maggiore 0 queste funzioni inseriranno n linee vuote sopra la corrente, quando n minore 0 verranno cancellate n linee e quelle seguenti sostate in su

int insstr(str)
int insnstr(str, n)
int winsstr(win, str)
int winsnstr(win, str, n)
int mvinsstr(y, x, str)
int mvinsnstr(y, x, str, n)
int mvwinsstr(win, y, x, str)
int mvwinsnstr(win, y, x, str, n)
Queste funzioni inseriranno str nella linea corrente a sinistra del cursore, spostandi in avanti i caratteri che seguono. Se questi superano il limite della riga verranno cancellati.

int delch()
int wdelch(win)
int mvdelch(y, x)
int mvwdelch(win, y, x)
delch cancella il carattere sotto il cursore oppure quello presente nelle posizioni x,y. I caratteri che seguono quello cancellato verranno spostati a sinistra di una posizione

int deleteln()
int wdeleteln(win)
Queste funzioni si occupano di cancellare la linea sotto il cursore e muovere quelle seguenti su di una posizione

int border(ls, rs, ts, bs, tl, tr, bl, br)
int wborder(win, ls, rs, ts, bs, tl, tr, bl, br)
int box(win, vert, hor)
Border costruisce un bordo in torno allo schermo o una finestra. ls,rs,ts,bs sono rispettivamente il carattere da usare per il lato sinistro, lato destro, lato superiore e lato inferiore. mentre tl, tr, bl, br sono i caratteri da usare rispettivamente per l'angolo superiore sinistro, superiore destro, inferiore sinistro ed inferiore destro. Box disegnerà un quadrato usando 0 agli angoli e vert, hor come caratteri per le linee verticali e orizzontali.

int vline(ch, n)
int wvline(win, ch, n)
int hline(ch, n)
int whline(win, ch, n)
vline ed hline generano una linea di n caratteri del tipo ch. Con vline la linea sarà verticale, con hline sarà orizzontale.

void bkgdset(ch)
void wbkgdset(win, ch)
Queste due funzioni impostano il carattere di sfondo per la finestra o schermo. Tutte le zone della finestra non aventi niente scritto sopra avranno quel carattere, ed esso farà parte integrante della finestra senza essere perso né con lo scrolling né con input/output.

int bkgd(ch)
int wbkgd(win, ch)
Queste due funzioni impostano gli attributi di background dello schermo o di una finestra e poi li passano a tutte le posizioni dello schermo o finestra