Biblioteca de manejo de cursores ncurses

La biblioteca ncurses proporciona funciones para actualizar pantallas en modo texto independientes del terminal en entornos UNIX y Linux.

Compilado y linkado

Para compilar un programa que use esta biblioteca hay que incluir el fichero de cabecera curses.h:
Para linkar un programa que use esta biblioteca hay que enlazar la biblioteca libncurses.a:

Las rutinas

Aunque esta biblioteca ofrece rutinas para múltiples aspectos, como manipulación de trozos de la pantalla, rutinas de consulta del entorno, información sobre el terminal, etc., en este documento nos restringiremos a comentar las funciones básicas necesarias para las prácticas de la asignatura. Por ejemplo, se pueden definir ventanas, que son entidades lógicas que representan segmentos independientes de la pantalla y se pueden manipular independientemente.

Rutinas de inicialización y finalización

Antes de ejecutar las otras funciones de esta biblioteca es necesario llamar a las rutinas de inicialización.
WINDOW *initscr(void);
Esta función determina el tipo de terminal e inicializa todas las estructuras de datos privadas de la biblioteca. También hace una primera llamada a la función refresh, que actualiza el aspecto de la pantalla. Si se produce algún error, imprime un mensaje indicándolo y acaba el programa. Si finaliza correctamente, devuelve un puntero a una estructura que hace referencia a la pantalla. Ese puntero se usará como parámetro en algunas funciones.
int keypad(WINDOW *win, bool bf);
Esta rutina activa y desactiva la función de procesado de caracteres especiales. Si está activada, el segundo parámetro es true, cuando se pulse una tecla especial, las funciones de lectura, como getch, devuelven un único valor, por ejemplo KEY_LEFT, para el cursor hacia arriba. Si está desactivada, la lectura de una tecla especial requiere dos caracteres, y por tanto dos lecturas, y es el usuario el que se tiene que encargar de interpretar los caracteres de estas teclas especiales.
int nodelay(WINDOW *win, bool bf);
Esta rutina permite activar la opción que hace que las lecturas de datos de teclado con getch no sean bloqueantes. Esto quiere decir que si se hace una lectura con getch y no hay ningún carácter disponible en el buffer de teclado, getch acaba y devuelve como resultado el valor constante ERR.
int noecho(void);
Las rutinas echo() y noecho() controlan si el carácter tecleado es escrito en pantalla (eco) al leerse con la rutina getch.
int nonl(void);
La rutinas nl() y nonl() controlan el funcionamiento de la tecla "retorno de carro" tanto en la lectura como en la escritura. Si se llama a nonl(), la lectura del retorno de carro, no añade una nueva línea, sino que su funcionamiento es controlado directamente por la aplicación.
int curs_set(int visibility);
Esta rutina set establece el aspecto del cursor: 0 -> invisible, 1 -> visible, 2 -> muy visible.
int endwin(void);
Al acabar de trabajar en el modo terminal, el programa debe llamar a esta rutina para restaurar los valores apropiados de las variables de entorno y seguir trabajando en el modo texto normal.

Rutinas de escritura

int move(int y, int x);
Este rutina mueve el cursor a la línea 'y' y la columna 'x'. Sin embargo, el cursor físico no se mueve en el terminal hasta que se hace una llamada a la función refresh(). La posición especificada es relativa a la esquina superior izquierda de la ventana, que tiene las coordenadas (0,0).
int addch(chtype ch);
Esta rutina escribe el carácter que se pasa como parámetro en la posición en la que esté el cursor y avanza el cursor a la siguiente posición. El carácter no se muestra en la pantalla hasta que se hace una llamada a la función refresh().
int echochar(chtype ch);
Esta rutina es equivalente a hacer una llamada a addch(ch) seguida de una llamada a refresh().
int addstr(const char cad[]);
Esta rutina escribe la cadena de caracteres que se pasa como parámetro en la pantalla. Es equivalenta a llamar a addch() para cada uno de los caracteres de la cadena.
int refresh(void);
Esta rutina hace que se muestre la salida en la pantalla, ya que las otras funciones simplemente manipulan estructuras de datos internas. El cursor se queda tras el último carácter escrito.
int erase(void);
Esta rutina borra la pantalla escribiendo blancos en todas las posiciones.

Rutinas de lectura

int getch(void);
Esta rutina lee un carácter del buffer de teclado. Si se está en modo de no espera (ver rutina nodelay), getch devuelve ERR si no hay ningún valor disponible. Si se está en modo de espera, la rutina no acaba hasta que se pulsa algún carácter.
Si el manejo de caracteres extendidos está activado (ver rutina keypad), las teclas extendidas se leen como un solo caracter y se identifican por un nombre que empieza por el prefijo KEY_. Por ejemplo: 
            KEY_DOWN        Los cuatro cursores
            KEY_UP          ...
            KEY_LEFT        ...
            KEY_RIGHT       ...
            KEY_HOME        Tecla Inicio
            KEY_BACKSPACE   Tecla Borrado
            KEY_F0          Teclas de funci\'{o}n (hasta KEY_F63)
int getstr(char str[]);
Esta rutina lee una cadena de caracteres y la guarda en el parámetro.

Otras rutinas

void getmaxyx(WINDOW *win, int y, int x);
Esta rutina devuelve el tamaño de la ventana, medido en columnas y líneas.

Algunos enlaces con más información

Ejemplo:

El siguiente programa mueve el carácter '@' por la pantalla circularmente siguiendo la pulsación de los cursores. El programa acaba cuando se pulsa la tecla ESC, que corresponde al carácter 27.
La línea de compilación es la siguiente:
g++ prueba-ncurses.cpp -o prueba-ncurses -lncurses 
#include <ncurses.h>

using namespace std;

int main()
{

  WINDOW *w;

  int tecla;

  int max_x, max_y, pos_x, pos_y;

  bool fin = false;


  w = initscr();

  keypad(w, TRUE);

  noecho();

  nonl();

  curs_set(0);

  erase();

  getmaxyx(w, max_y, max_x);

  pos_x = max_x / 2;
  pos_y = max_y / 2;

  do
  {
        move(pos_y, pos_x);
        addch('@');
        refresh();

    tecla = getch();

        move(pos_y, pos_x);
        addch(' ');
        refresh();

        switch(tecla)
        {
          case KEY_UP:
             pos_y = (pos_y + (max_y - 1)) % max_y;
             break;
          case KEY_LEFT:
             pos_x = (pos_x + (max_x - 1)) % max_x;
             break;
          case KEY_RIGHT:
             pos_x = (pos_x + 1) % max_x;
             break;
          case KEY_DOWN:
             pos_y = (pos_y + 1) % max_y;
             break;
          case 27: // tecla ESC
             fin = true;
             break;
        }

  }  while (!fin);

  endwin();

  return 0;
}


File translated from TEX by TTH, version 3.59.
On 28 Apr 2004, 11:38.