NCURSES e CONIO

NCURSES e CONIO so duas bibliotecas de funes em C voltadas para o desenvolvimento de

aplicaes que utilizam o console (janela de texto e teclado) como interface de entrada e sada.

No entanto, nenhuma das duas bibliotecas existe como padro da linguagem C (ANSI C). A biblioteca
NCURSES est disponvel em ambientes que geram cdigo executvel para Linux, ao passo que conio
comumente disponibilizada por ambientes e pacotes de programao C para Windows e/ou DOS.

O objetivo deste documento apresentar funcionalidades comuns de NCURSES e CONIO, e
exemplificando e explicando quais so as funes que implementam essas funcionalidades para cada
biblioteca.

1. Incluso no projeto e inicializao

NCURSES: a incluso/inicializao de NCURSES feita da seguinte maneira:
codificando-se #include <ncurses.h> no incio do cdigo- fonte
configurando-se o linker (ligador) para ligar as funes de NCURSES. No ambiente KDevelop
isso obtido a partir do menu Project Project Options Configure Options, preenchendo-se o
campo linker flags (LDFLAGS) com o texto lncurses
utilizando-se uma chamada a initscr() antes de utilizar qualquer outra funo de NCURSES. Por
exemplo:

#include <ncurses.h>
int main()
{
initscr();
printw(Esta uma funo de NCURSES. Ela s pode ser chamada depois da
chamada a initscr);
. . .
}

CONIO: a incluso/inicializao de CONIO feita da seguinte maneira:
codificando-se #include <conio.h> no incio do cdigo- fonte. Notar que alguns
ambientes de desenvolvimento (por exemplo, Dev-C++) no oferecem CONIO na forma de
biblioteca e sim como um arquivo fonte separado; nesse caso deve-se utilizar #include
<conio.c>

2. Posicionamento e sada de texto

NCURSES: utiliza-se a funo printw, que tem sintaxe idntica a printf, para sada de texto.
necessrio uma chamada a refresh() logo em seguida para permitir que os caracteres fornecidos a
printw sejam imediatamente exibidos no console.
O texto ser impresso a partir da posio do cursor, que pode ser configurada atravs de uma chamada
funo move(y, x), onde y o nmero da linha (comeando em 0 para a linha no alto do console e
crescendo para baixo) e x o nmero da coluna (comeando em 0 para a coluna esquerda e crescendo
para a direita).
Exemplo:

#include <ncurses.h>
int main()
{
initscr();
raw(); /* configura entrada por caracter */
noecho(); /* sem mostrar os caracteres digitados */
halfdelay(10); /* espera por tecla no mximo 1 segundo */
cur_set(0); /* no mostra o cursor */
move(10, 30); /* mais ou menos no meio do console */
printw(Texto no meio); /* mostra a partir da posio (10,30) */
refresh();
endwin(); /* funo para finalizar NCURSES */
return 0;
}

CONIO: utiliza-se a funo cprintf da biblioteca padro para sada de texto. Esta funo diferente de
printf porque utiliza as configuraes do console para imprimir (por exemplo, posicionamento e cores).
A posio do cursor pode ser configurada atravs de uma chamada funo gotoxy(x, y), onde x o
nmero da coluna (comeando em 1 para a coluna esquerda e crescendo para a direita) e y o nmero
da linha (comeando em 1 para a linha no alto do console e crescendo para baixo). O exemplo a seguir
mostra o mesmo posicionamento utilizado no exemplo de NCURSES, porm levando em considerao
que o sistema de coordenadas e a ordem dos argumentos de gotoxy so diferentes dos utilizados por
move.
Exemplo:

#include <conio.h>
int main()
{
gotoxy(31, 11); /* mais ou menos no meio do console */
cprintf(Texto no meio); /* mostra a partir da posio (31,11) */
return 0;
}



3. Configurao de entrada via teclado

NCURSES: os seguintes parmetros da entrada devem ser configurados a priori:
existncia ou no de eco (se os caracteres digitados so ou no so exibidos no console).
As funes echo() e noecho() ativam e desativam o eco, respectivamente.
exibio ou no do cursor. Pode ser configurado atravs de chamada a curs_set(opcao),
onde opcao 0 para esconder o cursor e 1 para exib- lo normalmente.
tempo de espera para funes de recebimento de tecla. Uma chamada a
halfdelay(decimos) configura as funes de recebimento para aguardar tecla por, no
mximo, decimos dcimos de segundo; caso nenhuma tecla seja recebida nesse intervalo
as funes retornam a constante ERR (significa erro). Uma maneira de configurar o
tempo de espera para zero chamar nodelay(stdscr, true).
se a entrada por linha (s aceita depois que se pressiona ENTER) ou por caracter (os
caracteres so aceitos medida que so digitados). A entrada por linha padro, se for
necessrio mud- la para caracter deve-se chamar a funo raw().
uso ou no de teclas especiais (teclas de funo, setas, etc.). Para iniciar o uso de teclas
especiais chamar a funo keypad(stdscr, true);
Exemplo:

#include <ncurses.h>
int main()
{
initscr();
raw(); /* configura entrada por caracter */
noecho(); /* sem mostrar os caracteres digitados */
halfdelay(10); /* espera por tecla no mximo 1 segundo */
cur_set(0); /* no mostra o cursor */
keypad(stdscr, true); /* inicializa a leitura de teclas especiais
para a janela padro */
. . .
return 0;
}

CONIO: podem ser configurados a priori:
exibio ou no do cursor, atravs da chamada a _setcursortype(tipo), onde tipo
_NOCURSOR (para esconder o cursor), _NORMALCURSOR (cursor normal) e
_SOLIDCURSOR (cursor slido).

Exemplo:

#include <conio.h>
int main()
{
_setcursortype(_NOCURSOR); /* a partir de agora no mostra o cursor nas
funes de impresso de texto */
. . .
return 0;
}

4. Entrada via teclado

NCURSES: a entrada de caracter pode ser feita ut ilizando-se wgetch(stdscr). Esta funo retorna o
cdigo do caracter correspondente tecla pressionada, ou ERR caso tenha expirado o tempo
configurado por halfdelay.
Para compatibilizao com a leitura de caracteres especiais, a varivel que recebe o retorno de wgetch
deve ser declarada como int.
Para a leitura das teclas de seta deve-se comparar o retorno de wgetch com uma das quatro constantes
pr-definidas em NCURSES: KEY_UP, KEY_DOWN, KEY_LEFT e KEY_RIGHT.
Para a entrada de texto em uma linha utiliza-se scanw, cujo funcionamento idntico ao do scanf
padro.

Exemplo:

#include <ncurses.h>
int main()
{
int tempo;
int carac;
initscr();
raw(); /* configura entrada por caracter */
noecho(); /* sem mostrar os caracteres digitados */
cur_set(0); /* no mostra o cursor */
keypad(stdscr, true); /* habilita o recebimento de teclas especiais */
printw(Por quantos segundos vc quer esperar por tecla?);
refresh();
scanw(%d, &tempo);
halfdelay(tempo*10); /* configura espera por tecla no mximo o tempo
fornecido */
carac = wgetch(stdscr); /* aguarda tecla */
if (carac == ERR)
{
printw(Demorou demais);
}
else
{
if ((carac == KEY_UP) || (carac == KEY_DOWN) || (carac == KEY_LEFT)
|| (carac == KEY_RIGHT))
{
printw(Vc digitou uma das setas!);
}
else
{
printw(A tecla digitada foi %c, carac);
}
}
endwin(); /* funo para finalizar NCURSES */
return 0;
}

CONIO: a entrada de caracter pode ser feita utilizando-se getch() (sem eco) ou getche() (com eco).
Estas funes retornam o cdigo ASCII do caracter correspondente tecla pressionada.
Para teclas especiais, como as teclas de seta, getch() retorna o nmero 0 e, se for chamada novamente,
retorna um cdigo que pode ser testado para identificar a tecla. Os cdigos das teclas de seta so os
seguintes:
Para cima: 72
Para baixo: 80
Para esquerda: 75
Para direita: 77

Considerando o fato que ambas getch() e getche() aguardam indefinidamente pela tecla, necessrio
verificar a priori se existe uma tecla disponvel para ser lida. Isso feita atravs da chamada funo
kbhit() , que retorna diferente de zero se uma tecla est disponvel e 0 caso contrrio. Como no existe
o conceito de tempo mximo de espera nesse caso, o exemplo mostra um cdigo- fonte no qual a funo
clock() de time.h est sendo utilizada para contar o tempo.

Exemplo:

#include <conio.h>
#include <stdio.h>
#include <time.h>
int main()
{
int t0, t1;
char carac;
printf(Por quantos segundos vc quer esperar por tecla?);
scanf(%d, &tempo);
t0 = clock();
do
{
t1 = clock();
} while (t1 < t0 + CLOCKS_PER_SEC*tempo); /* atraso */
if (kbhit() != 0)
{
carac = getch(); /* s l a tecla se ela est disponvel */
printf(A tecla digitada foi %c, carac);
}
else
{
printf(Demorou demais);
}
return 0;
}

5. Utilizao de cores no texto

NCURSES: a utilizao de cores no texto depende das seguintes etapas:
testar se o terminal que vai implementar o console suporta cores. Para tanto deve-se
chamar a funo has_colors() e testar o seu retorno, que TRUE se o terminal suporta
cores e FALSE caso contrrio.
inicializar o nmero de cores atravs de chamada a start_color().
configurar um par de cor de texto e cor de fundo de texto. Para tanto deve-se chamar a
funo init_pair(indice, cor_de_texto, cor_de_fundo) , onde indice um nmero pelo
qual aquele par ser conhecido e cor_de_texto e cor_de_fundo so constantes que
identificam as cores do texto e a cor do fundo (vide exemplo).
ligar/desligar o uso de um par de cores. Para esse fim devem ser chamadas as funes
attron(par) e attroff(par), onde par o resultado de uma macro COLOR_PAIR(indice)
com o ndice de um par previamente criado (vide exemplo).

Exemplo:

#include <ncurses.h>
int main()
{
int tempo;
char carac;
initscr();
raw(); /* configura entrada por caracter */
noecho(); /* sem mostrar os caracteres digitados */
cur_set(0); /* no mostra o cursor */
if (has_colors() == FALSE) /* testa se o terminal suporta cor */
{
printw(Esse terminal no suporta cor!);
endwin();
return 0;
}
start_color();
init_pair(1, COLOR_RED, COLOR_BLACK); /* cria o par 1 com texto vermelho
sobre fundo preto */
init_pair(2, COLOR_YELLOW, COLOR_BLUE); /* cria o par 2 com texto amarelo
sobre fundo azul */
attron(COLOR_PAIR(1)); /* ativa o par 1 */
printw(Esse texto possui cor vermelha sobre fundo preto\n);
attroff(COLOR_PAIR(1)); /* desativa o par 1 */
attron(COLOR_PAIR(2)); /* ativa o par 2 */
printw(Esse texto possui cor amarela sobre fundo azul\n);
attroff(COLOR_PAIR(2)); /* desativa o par 2 */
refresh();
endwin();
}

CONIO: fornece as funes textcolor(cor) e textbackground(cor) para ajustar as cores do texto e do
fundo do texto, respectivamente. O argumento cor uma das constantes pr-definidas, normalmente o
nome da cor em ingls em letras maisculas(p. ex., RED, CYAN, WHITE, BLACK).
Lembrar que o texto s ser exibido na cor configurada se for utilizado cprintf.


Exemplo:

#include <conio.h>
#include <stdio.h>
int main()
{
textcolor(RED); /* cor do texto para vermelho */
textbackground(BLACK); /* cor de fundo para preto */
cprintf(Esse texto possui cor vermelha sobre fundo preto\n);
textcolor(YELLOW); /* cor do texto para amarelo */
textbackground(BLUE); /* cor do fundo para azul */
cprintf(Esse texto possui cor amarela sobre fundo azul\n);
return 0;
}