\author{Sven van der Meer}
\date{v0.3.3, 19 Jan 1995}

%% MARCAS COLABORADORES: *-?-START y *-?-END. Ej: CBALLARD-1-START

\newcommand{\notenm}[1]{({\bf Nota:} #1.)}%                 normal Note:
\newcommand{\noteni}{\notenm{no implementado aun}}%         Note: not implemented
\newcommand{\notenie}[1]{\notenm{no implementado aun, #1}}% Note + #1 on begin
\newcommand{\notenib}[1]{\notenm{#1 no implementado aun}}%  Note + #1 on end

\newcommand{\vdmarg}[1]{{\tt #1}}  % function arguments in description
\newcommand{\vdmfunc}[1]{{\bf #1}} % functions in description
\newcommand{\vdmunix}[1]{{\sl#1}}  % unix related stuff in description
\newcommand{\vdmscr}[1]{{\sl#1}}   % stdscr and curscr
\newcommand{\vdmlines}[1]{{\sl#1}} % for LINES and COLS

\newcommand{\tabref}[1]{tabla \ref{#1} en la p\'agina \pageref{#1}}    % for tabular
\newcommand{\figref}[1]{figura \ref{#1} en la p\'agina \pageref{#1}}   % figures
\newcommand{\secref}[1]{secci\'on \ref{#1} en la p\'agina \pageref{#1}}  % for sections
\newcommand{\funref}[1]{\pageref{#1}}          % reference for functions

\newcommand{\ncver}{1.8.6}   % current ncurses version



\chapter{\label{vdm}Gr\'aficos en modo car\'acter}

Este cap\'{\i}tulo se dedica a las entradas y salidas de pantalla que no se basan en pixels, sino en caracteres. Cuando decimos car\'acter, queremos decir una
composici\'on de pixels que pueden cambiarse dependiendo de un conjunto de caracteres. Su tarjeta gr\'afica ya dispone de uno o m\'as charsets y opera en modo
texto por defecto, porque el texto puede procesarse mucho m\'as r\'apido que un gr\'afico de pixel. Se pueden hacer m\'as cosas con los terminales que simplemente
mostrar texto. Describir\'e como usar los aspectos especiales que su terminal linux , especialmente los que ofrece la consola el linux. 

\begin{itemize}
  \item {\bf printf, sprintf, fprintf, scanf, sscanf, fscanf} \\
	Con estas funciones de \vdmunix{libc} podr\'a realizar salida con
	formato sobre \vdmunix{stdout} (la salida est\'andar),
	\vdmunix{stderr} (la salida de errores est\'andar) y otros {\it
	streams} definidos como \vdmarg{FILE *stream} (ficheros, por
	ejemplo). La funci\'on \vdmfunc{scanf(...)} proporciona un mecanismo
	similar para entradas con formato, desde \vdmunix{stdin} (la
	entrada est\'andar).

  \item {\bf termcap} \\
La base de datos {\it termcap} (CAPacidades de TERMinal) es un
conjunto de entradas de descripci\'on de terminales en el archivo ASCII
/etc/termcap. Aqu\'{\i} puede encontrar la
informaci\'on sobre c\'omo mostrar caracteres especiales, como realizar operaciones (borrar, insertar caracteres o l\'{\i}neas, etc) y como inicializar un terminal. La
base de datos se usa, por ejemplo, por el editor vi. Hay funciones de biblioteca de vista para leer y usar las capacidades terminales (\vdmunix{termcap(3x)}). Con esta
base de datos, los programas pueden trabajar con una variedad de terminales con el mismo c\'odigo. El uso de la biblioteca de funciones termcap y la base de
datos proporciona s\'olo acceso a bajo nivel al terminal. El cambio de los atributos o colores o atributos, y la optimizaci\'on debe ser hecha por el mismo
programador.

\item  {\bf base de datos terminfo} \\
	La base de datos {\it terminfo} (INFOrmaci\'on de TERMinales) se
	basa en la base de datos {\it termcap} y tambi\'en describe las
	capacidades de las terminales, pero sobre un nivel m\'as alto que
	termcap. Usando terminfo, el programa puede cambiar f\'acilmente los
	atributos, usar teclas especiales tales como teclas de funci\'on y
	m\'as. La base de datos puede encontrarse en
	\vdmunix{/usr/lib/terminfo/[A-z,0-9]*}. Cada archivo describe un
	de terminal.

  \item {\bf curses} \\
	Terminfo es una base buena para usar en el manejo de un terminal
	en un programa. La biblioteca (BSD -)CURSES da acceso a alto nivel
	al terminal y se base en la base de datos terminfo. Curses le
	permite abrir y manipular 
	ventanas sobre la pantalla, proporciona un conjunto completo de
	funciones de entrada y salida, y puede alterar atributos de video
	de una manera independiente del terminal sobre m\'as de 150
	terminales. La biblioteca de curses puede encontrarse en
	\vdmunix{/usr/lib/libcurses.a}. Esta es el la versi\'on BSD curses.

  \item {\bf ncurses} \\
Ncurses es la siguiente mejora. La versi\'on \ncver debe ser compatible
con curses de AT\&T como se define en SYSVR4 y tiene algunas extensiones
tales como manipulaci\'on de color, optimizaci\'on especial para el
salida, optimizaciones espec\'{\i}ficas de terminales, y m\'as. Se ha probado
sobre muchos sistemas tales como SUN-OS, HP y Linux. Yo recomiendo
usar ncurses en vez de las otras. Sobre Unix SYSV de sistemas (tal
como Sun Solaris) deber existir una biblioteca de curses con la misma funcionalidad que ncurses (realmente las curses de solaris tienen algunas funciones m\'as y soporte de rat\'on). 
\end{itemize}

En las secciones siguientes describir\'e como usar los diferentes paquetes diferentes para acceder a un terminal. Con Linux tenemos la versi\'on GNU de termcap
y nosotros podemos usar ncurses en vez de curses. 






\section{Funciones E/S en la libc}

\subsection{Salida con Formato}\label{sec_formout}


Las funciones del grupo \vdmfunc{printf(...)} proporciona una salida
formateada y permite la conversi\'on de los argumentos.

\begin{itemize}
  \item {\tt int fprintf(FILE *stream, const char *formato, ...),}
  \label{fun_fprintf}\\
  transformar\'a la salida (argumentos para rellenar en \vdmarg{...}) y lo
  escribir\'a en un stream. El formato definido en \vdmarg{formato} se
  escribe tambi\'en. La funci\'on devuelve el n\'umero de caracteres
  escritos o un valor negativo en caso de error.

        El \vdmarg{formato} contiene dos tipos de objetos:
        \begin{enumerate}
         \item  caracteres normales para la salida
         \item  informaci\'on de c\'omo transformar o dar formato a los argumentos
        \end{enumerate}

        La informaci\'on del formato debe comenzar con el s\'{\i}mbolo {\it
        \%}, seguido de valores apropiados para el formato y de un
        car\'acter para la traducci\'on (para imprimir el propio signo
        {\it \%} usaremos el comando {\tt \%\%}). Los posibles valores
        para el formato son:

\begin{itemize}
 \item Flags
  \begin{itemize}
   \item {\tt -} \\
   El argumento formateado se imprimir\'a en el margen izquierdo (por
   defecto va en el margen derecho del campo para el argumento).
   \item {\tt +} \\
   Cada n\'umero ser\'a impreso con su signo, por ejemplo {\tt +12} o
   {\tt -2.32}.
  \end{itemize}
 \item Blanco \\
  Cuando el primer car\'acter no es un signo, se insertar\'a un blanco.
 \item {\tt 0} \\
 Para transformaciones num\'ericas la anchura del campo se rellenar\'a con
  ceros a la izquierda.   
 \item {\tt \#} \\
  Salida alternativa dependiendo de las transformaciones para los argumentos
  \begin{itemize}
   \item  Para {\it o} el primer n\'umero es un {\it 0}.
   \item  Para {\it x} o {\it X} se imprimir\'a {\it 0x} o {\it 0X}
  delante del argumento.
   \item  Para {\it e}, {\it E}, {\it f} o {\it F} la salida tiene
  punto decimal.
   \item  Para {\it g} o {\it G} se imprimen ceros al final del argumento.
  \end{itemize}
 \item Un n\'umero para la amplitud m\'{\i}nima del campo.\\
  El argumento transformado se imprime en un campo que, al menos, es tan
  grande como el mismo argumento. Para n\'umeros, puede hacer la anchura
  del campo m\'as grande. Si el argumento formateado es m\'as peque\~no, entonces la
  anchura del campo se rellenar\'a con ceros o blancos.
 \item  Un punto separa la anchura del campo de la precisi\'on.
 \item  Un n\'umero para la precisi\'on.
\end{itemize}

  Valores posibles para la transformaci\'on est\'an en la \tabref{tab_printf}.

  \item {\tt int printf(const char *formato, ...)} \label{fun_printf}\\
        Similar a \vdmfunc{fprintf(stdout, ...)}.

  \item {\tt int sprintf(char *s, const char *formato, ...)} \label{fun_sprintf}\\
        Similar a \vdmfunc{printf(...)}, con la salvedad de que la
        salida es escrita en la cadena apuntada por el puntero
        \vdmarg{s} (terminada en {\it \verb+\+0}).

        \notenm{Debe haberse reservado memoria suficiente para \vdmarg{s}}

\item {\tt vprintf(const char *formato, va\_list arg)} \label{fun_vprintf}\\
      {\tt vfprintf(FILE *stream, const char *formato, va\_list arg)} \label{fun_vfprintf}\\
      {\tt vsprintf(char *s, const char *formato, va\_list arg)}
      \label{fun_vsprintf}\\
      Funciones similares a las anteriores, aunque ahora la lista de
      argumentos se introduce en \vdmarg{arg}.
\end{itemize}

\begin{table}
  \caption{Libc - transformaciones en printf} \label{tab_printf}
  \begin{center}
    \begin{tabular}{c|l}
    {\bf Car\'acter} &  {\bf Formateado a} \\ \hline
    d,i &  {\it entero} con signo, decimal \\
    o   &  {\it entero} sin signo, octal, sin ceros a la izquierda \\
    x,X &  {\it entero} sin signo, hexadecimal sin cabecera 0x \\
    u   &  {\it entero} sin signo, decimal \\
    c   &  {\it entero} (sin signo), como car\'acter \\
    s   &  {\it char *} hasta el \verb+\+0 \\
    f   &  coma flotante ({\it double}), como [-]mmm.ddd \\
    e,E &  coma flotante ({\it double}) como [-]m.dddddde$\pm$xx \\
    g,G &  coma flotante ({\it double}) usando \%e o \%f si es necesario \\
    p   &  {\it void *} \\
    n   &  {\it int *} \\
    \%  &  {\it \%} \\
    \end{tabular}
  \end{center}
\end{table}



\subsection{Entrada con Formato}\label{sec_formin}

Igual que usamos \vdmfunc{printf(...)} para salidas con formato,
tambi\'en podemos usar \vdmfunc{scanf(...)} para entradas con formato.

\begin{itemize}
  \item {\tt int fscanf(FILE *stream, const char *formato, ...)} \label{fun_fscanf}\\

\vdmfunc{fscanf(...)} lee de un \vdmarg{stream} y transformar\'a la entrada con
las reglas definidas en el \vdmarg{formato}. El resultado se sit\'ua en el
argumento dado por \vdmarg{...}. (Observe que los argumentos deben ser
punteros). La lectura termina cuando no hay m\'as reglas de
transformaci\'on en el formato. \vdmfunc{fscanf(...)} devolver\'a EOF cuando la
primera transformaci\'on alcance el final del archivo u ocurra alg\'un
error. En otro caso devolver\'a el n\'umero de argumentos transformados.

        El \vdmarg{formato} puede incluir reglas para dar formato a
los caracteres de entrada (vea la \tabref{tab_scanf}). Tambi\'en puede incluir:
can include rules on how to format the input arguments
        \begin{itemize}
          \item Espacios o tabuladores, que son ignorados.
          \item Cualquier car\'acter normal (salvo \%). Los caracteres
deben estar en la entrada, en la misma posici\'on.
          \item Reglas de transformaci\'on, precedidas de un {\it \%},
con el car\'acter opcional {\it *} (esto permitir\'a a
\vdmfunc{fscanf(...)} asignarlo a un argumento), un n\'umero opcional,
un car\'acter opcional {\it h, l o L} (para la longitud del objetivo) y
el car\'acter de transformaci\'on.
  \end{itemize}

  \item {\tt int scanf(const char *formato, ...)} \label{fun_scanf}\\
        Equivalente a \vdmfunc{fscanf(stdin,...)}.

  \item {\tt int sscanf(char *str, const char *format, ...)} \label{fun_sscanf}\\
        Similar a \vdmfunc{scanf(...)}, aunque ahora la entrada se lee
        de la cadena \vdmarg{str}.
\end{itemize}


\begin{table}
  \caption{Libc - transformaciones en scanf} \label{tab_scanf}
  \begin{center}
    \begin{tabular}{c|l}
    {\bf Car\'acter} &  {\bf Entrada - Tipo del argumento} \\ \hline
    d   &  entero decimal - {\it int *}\\
    i   &  entero - {\it int *} (la entrada puede ser octal o hexadecimal)\\
    o   &  entero octal - {\it int *} (con 0 a la izquierda opcional)\\
    u   &  decimal, sin signo - {\it unsigned int *}\\
    x   &  entero hexadecimal - {\it int *} (con 0x a la izquierda opcional)\\
    c   &  uno o m\'as caracteres - {\it char *} (sin el \verb+\+0)\\
    s   &  caracteres (sin separadores) - {\it char *} (con el \verb+\+0)\\
e,f,gf  &  coma flotante - {\it float *} (ej: [-]m.dddddde$\pm$xx)\\
    p   &  puntero - {\it void *}\\
    n   &  n\'umero de argumentos transformados - {\it int *}\\
$[...]$ &  caracteres de la entrada - {\it char *}\\
$[$\^{}$...]$ &  excluir esos caracteres - {\it char *}\\
    \%  &  {\it \%}\\ \hline
    \multicolumn{2}{l}{{\it h} puede ir antes de d,i,n,o,u y x, cuando
  el puntero es tipo {\it short}}\\
    \multicolumn{2}{l}{{\it l} puede ir antes de d,i,n,o,u y x, cuando
  el puntero es {\it long}}\\
    \multicolumn{2}{l}{{\it l} puede ir antes de e,f y g cuando el
  puntero es {\it double}}\\
    \multicolumn{2}{l}{{\it L} puede ir antes de e,f y g cuando el
  puntero es {\it long double}}\\
    \end{tabular}
  \end{center}
\end{table}




\section{La Librer\'{\i}a Termcap}


\subsection{Introducci\'on}

La librer\'{\i}a Termcap es una API (Interfaz de Programaci\'on de
Aplicaci\'on) con la base de datos {\it termcap} que se encuentra en
\vdmunix{/etc/termcap/}. Las funciones de esta librer\'{\i}a permiten
realizar las siguientes acciones:

\begin{itemize}
  \item Obtener descripci\'on del terminal actual: \vdmfunc{tgetent(...)}.
  \item Buscar la descripci\'on para informaci\'on:
        \vdmfunc{tgetnum(...)}, \vdmfunc{tgetflag(...)}, 
        \vdmfunc{tgetstr(...)}.
  \item Codificar par\'ametros num\'ericos en la forma de un terminal espec\'{\i}fico:
        \vdmfunc{tparam(...)}, \vdmfunc{tgoto(...)}.
  \item Calcular y realizar rellenos \vdmfunc{tputs(...)}.
\end{itemize}

Los progamas que usan la biblioteca termcap deben incluir
\vdmunix{termcap.h} y deben ser enlazados con {\tt libtermcap} de esta
forma:

\begin{tscreen}
\begin{verbatim}
    gcc [opciones] ficheros -ltermcap
\end{verbatim}
\end{tscreen}

Las funciones termcap son rutinas independientes del terminal, pero s\'olo dan al programador acceso a bajo nivel. Para un manejo de alto nivel
tenemos que usar curses o ncurses.


\subsection{Encontrar la descripci\'on del terminal}

\begin{itemize}
  \item {\tt int tgetent(void *buffer, const char *tipoterm)} \label{fun_tgetent}\\
      En el sistema operativo Linux, el nombre de la clase de terminal
      actual se encuentra en la variable de entorno
      \vdmunix{TERM}. Por tanto, el argumento \vdmarg{tipoterm} lo
      obtendremos mediante la funci\'on \vdmunix{getenv(3)}.

      Cuando usamos la versi\'on {\it termcap} de GNU (lo habitual bajo
      Linux), no es necesario reservar memoria para el
      \vdmarg{buffer}. En otras implementaciones habr\'a que reservar
      2048 bytes (realmente son 1024, pero el tama\~no fue doblado).

     \vdmfunc{tgetent(...)} devuelve 1 cuando hay \'exito, y 0 si no se
     encuentra informaci\'on para ese terminal en la base de
     datos. Otros errores devolver\'an diferentes valores.

	 El siguiente ejemplo nos ayudar\'a a ver c\'omo se usa la funci\'on
     \vdmfunc{tgetent(...)}:

\begin{tscreen}
\begin{verbatim}
    #define buffer 0
    char *tipoterm=getenv("TERM");
    int ok;

    ok=tgetent(buffer,tipoterm);
    if(ok==1)
      /* todo va bien, se ha encontrado la informacion */
    else if(ok==0)
     /* algo va mal con TERM
      * comprobar tipoterm y luego la propia base de datos
      */
    else
     /* este caso corresponde a un error fatal */
\end{verbatim}
\end{tscreen}

    Por defecto, la base de datos se encuentra en
	\vdmunix{/etc/termcap/}. Si existe la variable de entorno TERMCAP,
	por ejemplo con el valor \vdmunix{\$HOME/mytermcap}, las funciones
	de la librer\'{\i}a buscar\'an la base de datos en ese nuevo
	directorio. Sin barras iniciales en TERMCAP, el valor definido se
	usar\'a como nombre y descripci\'on del terminal. \end{itemize}

\subsection{Lectura de una descripci\'on de terminal}

Cada parte de la informaci\'on se llama {\it capacidad}, cada capacidad,
es un c\'odigo de dos letras, y cada c\'odigo de dos letras viene seguido
de por el valor de la capacidad. Los tipos posibles son:

\begin{itemize}
  \item  {\bf Num\'erico}: Por ejemplo, {\it co} -- n\'umero de columnas
  \item  {\bf Booleano} o {\bf Flag}: Por ejemplo, {\it hc} -- terminal
         hardcopy
  \item  {\bf Cadena}: Por ejemplo, {\it st} -- set tab stop
\end{itemize}

Cada capacidad est\'a asociada con un valor individual. ({\it co} es
siempre num\'erico, {\it hc} es siempre un flag y {\it st} es siempre un
string).Hay tres tipos diferentes de valores, y por tanto hay tres
funciones para interrogarlos. \vdmarg{char *nombre} es el c\'odigo de dos letras
para la capacidad.

\begin{itemize}
  \item {\tt int tgetnum(char *nombre)} \label{fun_tgetnum}\\
Obtiene el valor de una capacidad que es num\'erica, tal como {\it
co}. \vdmfunc{tgetnum(...)} devuelve el valor num\'erico si la capacidad
est\'a disponible, en otro caso 1. (Observe que el valor devuelto no es
negativo).

  \item {\tt int tgetflag(char *nombre)} \label{fun_tgetflag}\\
Obtiene el valor de una capacidad que es boolean (o flag). Devuelve 1
si la badera (flag) est\'a presente, 0 en otro caso.

  \item {\tt char *tgetstr(char *nombre, char **area)} \label{fun_tgetstr}\\
Obtiene el valor de una capacidad que es un string. Devuelve un
puntero al string o NULL si no est\'a presente. En la versi\'on GNU, si
\vdmarg{area} es NULL, termcap ubicar\'a memoria para \'el. Termcap no
har\'a m\'as referencia a ese puntero, de forma que no olvide liberar el
\vdmarg{nombre} antes de terminar el programa. Este m\'etodo es preferido, porque
no tiene que saber cu\'anto espacio se necesita para el puntero, as\'{\i} que
deje a termcap hacerlo por vd.
\end{itemize}


\begin{tscreen}
\begin{verbatim}
    char *clstr, *cmstr;
    int   lines,  cols;

    void term_caps()
    {
    char *tmp;

     clstr=tgetstr("cl",0); /* limpiar pantalla */
     cmstr=tgetstr("cm",0); /* mover y,x     */

     lines=tgetnum("li"); /* lineas del terminal   */
     cols=tgetnum("co");  /* columnas del terminal */

     tmp=tgetstr("pc",0); /* caracter separador */

     PC=tmp ? *tmp : 0;
     BC=tgetstr("le",0); /* cursor un caracter a la izquierda */
     UP=tgetstr("up",0); /* cursor arriba una linea   */
    }
\end{verbatim}
\end{tscreen}



\subsection{Capacidades de Termcap}

\subsubsection{Capacidades Booleanas}
\begin{small}
\begin{tabbing}
1234\=\kill
{\tt 5i} \>   La impresora no har\a'a eco en la pantalla\\
{\tt am} \>   M\a'argenes autom\a'aticos\\
{\tt bs} \>   Control-H (8 dec.) realiza un backspace\\
{\tt bw} \>   Backspace al margen izquierdo vuelve la margen derecho e la l\a'{\i}nea superior\\
{\tt da} \>   Display retenido sobre la pantalla\\
{\tt db} \>   Display retenido bajo la pantalla\\
{\tt eo} \>   Un espacio borra todos los caracteres de la posici\a'on del cursor\\
{\tt es} \>   Secuencias de Escape y caracteres especiales funcionan en la l\a'{\i}nea de estado\\
{\tt gn} \>   Dispositivo Gen\a'erico\\
{\tt hc} \>   Esto es un terminal de copia f\a'{\i}sica (hardcopy terminal)\\
{\tt HC} \>   El cursor es dif\a'{\i}cil de ver cuando no est\a'a en la l\a'{\i}nea de abajo\\
{\tt hs} \>   Tiene l\a'{\i}nea de estado\\
{\tt hz} \>   ``Hazel tine bug'', el terminal no puede imprimir caracteres con tilde\\
{\tt in} \>   Terminal inserta nulos, no espacios, para rellenar blancos\\
{\tt km} \>   Terminal tiene tecla ``meta'' (alt)\\
{\tt mi} \>   Los movimientos del cursor funcionan en modo inserci\a'on\\
{\tt ms} \>   Los movimientos del cursor funcionan en modo standout/subrayado\\
{\tt NP} \>   Sin car\a'acter de ``padding''\\
{\tt NR} \>   ``ti'' no invierte ``te''\\
{\tt nx} \>   No hay ``padding'', debe usarse XON/XOFF\\
{\tt os} \>   Terminal can overstrike\\
{\tt ul} \>   Terminal underlines although it can not overstrike\\
{\tt xb} \>   f1 env\a'{\i} ESCAPE, f2 env\a'{\i} \^{}C\\
{\tt xn} \>   Newline/wraparound glitch\\
{\tt xo} \>   El terminal usa protocolo xon/xoff\\
{\tt xs} \>   Text typed over standout text will be displayed in standout\\
{\tt xt} \>   Teleray glitch, destructive tabs and odd standout mode\\
\end{tabbing}
\end{small}

\subsubsection{Capacidades Num\'ericas}
\begin{small}
\begin{multicols}{2}
\begin{tabbing}
1234\=\kill
{\tt co} \>   N\a'umero de columnas\\
{\tt dB} \>   Retardo (ms) para el retroceso\\
         \>   en terminales de copia f\a'{\i}sica\\
{\tt dC} \>   Retardo (ms) para el retorno de\\
         \>   carro en terminales de copia f\a'{\i}sica\\
{\tt dF} \>   Retardo (ms) para alim. p\a'agina\\
         \>   en terminales de copia f\a'{\i}sica\\
{\tt dN} \>   Retardo (ms) para fin de l\a'{\i}nea\\
         \>   en terminales de copia f\a'{\i}sica\\
{\tt dT} \>   Retardo (ms) para parada de tabulaci\a'on\\
         \>   en terminales de copia f\a'{\i}sica\\
{\tt dV} \>   Retardo (ms) para parada de tabulaci\a'on\\
         \>   vertical en terminales de copia f\a'{\i}sica\\
{\tt it} \>   Diferencia entre posiciones de tabulaci\a'on\\
{\tt lh} \>   Alto de los 'soft labels'\\
{\tt lm} \>   L\a'{\i}neas de memoria\\
{\tt lw} \>   Ancho de los 'soft labels'\\
{\tt li} \>   N\a'umero de l\a'{\i}neas\\
{\tt Nl} \>   N\a'umero de 'soft labels'\\
{\tt pb} \>   M\a'{\i}nimo ratio en baudios que\\
         \>   necesita 'padding'\\
{\tt sg} \>   Standout glitch\\
{\tt ug} \>   Underline glitch\\
{\tt vt} \>   N\a'umero de terminal virtual\\
{\tt ws} \>   Ancho de l\a'{\i}nea de estado si\\
         \>   difiere del ancho de pantalla\\
\end{tabbing}
\end{multicols}
\end{small}
%\clearpage

\subsubsection{Capacidades con Cadenas}
\begin{small}
\begin{multicols}{2}
\begin{tabbing}
1234\=\kill
{\tt !1} \>   tecla de salvar con shift\\
{\tt !2} \>   tecla de suspensi\a'on con shift\\
{\tt !3} \>   tecla de deshacer con shift\\
{\tt \#1} \>  tecla de ayuda con shift\\
{\tt \#2} \>  tecla de inicio con shift\\
{\tt \#3} \>  tecla de entrada con shift\\
{\tt \#4} \>  tecla con shift de cursor izquierda\\
{\tt \%0} \>  tecla de rehacer\\
{\tt \%1} \>  tecla de ayuda\\
{\tt \%2} \>  tecla de selecci\a'on\\
{\tt \%3} \>  tecla de mensaje\\
{\tt \%4} \>  tecla de mover\\
{\tt \%5} \>  tecla de siguiente objeto\\
{\tt \%6} \>  tecla de abrir\\
{\tt \%7} \>  tecla de opciones\\
{\tt \%8} \>  tecla de objeto anterior\\
{\tt \%9} \>  tecla de imprimir\\
{\tt \%a} \>  tecla de mensajes con shift\\
{\tt \%b} \>  tecla de mover con shift\\
{\tt \%c} \>  tecla de siguiente, con shift\\
{\tt \%d} \>  tecla de opciones con shift\\
{\tt \%e} \>  tecla de anterior, con shift\\
{\tt \%f} \>  tecla de imprimir, con shift\\
{\tt \%g} \>  tecla de rehacer, con shift\\
{\tt \%h} \>  tecla de reemplazar, con shift\\
{\tt \%i} \>  tecla de cursor dcha. con shift\\
{\tt \%j} \>  tecla continuar con shift\\
{\tt \&0} \>  tecla cancelar con shift\\
{\tt \&1} \>  tecla de referencia\\
{\tt \&2} \>  tecla de refrescar\\
{\tt \&3} \>  tecla de reemplazar\\
{\tt \&4} \>  tecla de reinicio\\
{\tt \&5} \>  tecla de continuar\\
{\tt \&6} \>  tecla de salvar\\
{\tt \&7} \>  tecla de suspensi\a'on\\
{\tt \&8} \>  tecla deshacer\\
{\tt \&9} \>  tecla de inicio con shift\\
{\tt *0} \>   tecla de buscar con shift\\
{\tt *1} \>   tecla de comando con shift\\
{\tt *2} \>   tecla de copiar con shift\\
{\tt *3} \>   tecla de crear con shift\\
{\tt *4} \>   car\a'acter de borrado con shift\\
{\tt *5} \>   borrar l\a'{\i}nea con shift\\
{\tt *6} \>   tecla de selecci\a'on\\
{\tt *7} \>   tecla de fin con shift\\
{\tt *8} \>   limpiar l\a'{\i}nea con shift\\
{\tt *9} \>   tecla de salida con shift\\
{\tt \@0} \>   tecla de buscar\\
{\tt \@1} \>   tecla de inicio\\
{\tt \@2} \>   tecla de cancelar\\
{\tt \@3} \>   tecla de cerrar\\
{\tt \@4} \>   tecla de comando\\
{\tt \@5} \>   tecla de copiar\\
{\tt \@6} \>   tecla de crear\\
{\tt \@7} \>   tecla de fin\\
{\tt \@8} \>   tecla de entrar/enviar\\
{\tt \@9} \>   tecla de salir\\
{\tt al} \>   Insertar una l\a'{\i}nea\\
{\tt AL} \>   Insertar \%1 l\a'{\i}neas\\
{\tt ac} \>   Pairs of block graphic characters to\\ 
         \>   map alternate character set\\
{\tt ae} \>   Fin de juego de caracteres alternativo\\
{\tt as} \>   Iniciar juego de caracteres alternativo\\
         \>   para caracteres gr\a'ficos de bloques\\
{\tt bc} \>   Car\a'cter de retroceso, si no es \^{}H\\
{\tt bl} \>   Pitido ac\a'ustico\\
{\tt bt} \>   Moverse a la parada de tabulaci\a'on previa\\
{\tt cb} \>   Limpiar desde comienzo de l\a'{\i}nea\\
         \>   hasta el cursor\\
{\tt cc} \>   Car\a'cter comod\a'{\i}n de comando\\
{\tt cd} \>   Limpiar hasta final de pantalla\\
{\tt ce} \>   Limpiar hasta final de l\a'{\i}nea\\
{\tt ch} \>   Mover cursor horizontalmente hasta la\\
              columna \%1\\
{\tt cl} \>   Limpiar pantalla y devolver cursor al principio\\
{\tt cm} \>   Mover cursor a la fila \%1 y\\
              columna \%2 (de la pantalla)\\
{\tt CM} \>   Mover cursor a la fila \%1 y\\
              la columna \%2 (de la memoria)\\
{\tt cr} \>   Retorno de carro\\
{\tt cs} \>   Mover regi\a'on de l\a'{\i}nea \%1 a la \%2\\
{\tt ct} \>   Limpiar tabuladores\\
{\tt cv} \>   Mover cursor a la\\
         \>   l\a'{\i}nea \%1\\
{\tt dc} \>   Borrar un car\a'acter\\
{\tt DC} \>   Borrar \%1 caracteres\\
{\tt dl} \>   Borrar una l\a'{\i}nea\\
{\tt DL} \>   Borrar \%1 l\a'{\i}neas\\
{\tt dm} \>   Inicio del modo borrado\\
{\tt do} \>   Bajar cursor una l\a'{\i}nea\\
{\tt DO} \>   Bajar cursor \#1 l\a'{\i}neas\\
{\tt ds} \>   Desactivar l\a'{\i}nea de estado\\
{\tt eA} \>   Activar juego de caracteres alternativo\\
{\tt ec} \>   Borrar \%1 caracteres desde el cursor\\
{\tt ed} \>   Fin del modo borrado\\
{\tt ei} \>   Fin del modo inserci\a'on\\
{\tt ff} \>   Car\a'acter de salto de p\a'gina en\\
         \>   terminales de copia f\a'{\i}sica\\
{\tt fs} \>   Devolver car\a'acter a posicion antes\\
         \>   de ir a la l\a'{\i}nea de estado\\
{\tt F1} \>   Cadena enviada por tecla f11\\
{\tt F2} \>   Cadena enviada por tecla f12\\
{\tt F3} \>   Cadena enviada por tecla f13\\
         \>   ...  ...\\
{\tt F9} \>   Cadena enviada por tecla f19\\
{\tt FA} \>   Cadena enviada por tecla f20\\
{\tt FB} \>   Cadena enviada por tecla f21\\
         \>   ...  ...\\
{\tt FZ} \>   Cadena enviada por tecla f45\\
{\tt Fa} \>   Cadena enviada por tecla f46\\
{\tt Fb} \>   Cadena enviada por tecla f47\\
         \>   ...  ...\\
{\tt Fr} \>   Cadena enviada por tecla f63\\
{\tt hd} \>   Bajar el cursor una l\a'{\i}nea\\
{\tt ho} \>   Vuelta del cursor al principio\\
{\tt hu} \>   Mover cursor media l\a'{\i}nea arriba\\
{\tt i1} \>   Cadena de inicio 1 al entrar (login)\\
{\tt i3} \>   Cadena de inicio 2 al entrar (login)\\
{\tt is} \>   Cadena de inicio 3 al entrar (login)\\
{\tt ic} \>   Inserar un car\a'acter\\
{\tt IC} \>   Insertar \%1 caracteres\\
{\tt if} \>   Fichero de inicio\\
{\tt im} \>   Entrar en modo inserci\a'on\\
{\tt ip} \>   Insert pad time and needed special\\
         \>   characters after insert\\
{\tt iP} \>   Programa de inicio\\
{\tt K1} \>   tecla superior izquierda en teclado de n\a'umeros\\
{\tt K2} \>   tecla central en teclado de n\a'umeros\\
{\tt K3} \>   tecla superior derecha en teclado de n\a'umeros\\
{\tt K4} \>   tecla inferior izquierda en teclado de n\a'umeros\\
{\tt K5} \>   tecla inferior derecha en teclado de n\a'umeros\\
{\tt k0} \>   Tecla de funci\a'on 0\\
{\tt k1} \>   Tecla de funci\a'on 1\\
{\tt k2} \>   Tecla de funci\a'on 2\\
{\tt k3} \>   Tecla de funci\a'on 3\\
{\tt k4} \>   Tecla de funci\a'on 4\\
{\tt k5} \>   Tecla de funci\a'on 5\\
{\tt k6} \>   Tecla de funci\a'on 6\\
{\tt k7} \>   Tecla de funci\a'on 7\\
{\tt k8} \>   Tecla de funci\a'on 8\\
{\tt k9} \>   Tecla de funci\a'on 9\\
{\tt k;} \>   Tecla de funci\a'on 10\\
{\tt ka} \>   Limpiar todas las tabulaciones\\
{\tt kA} \>   Tecla de insertar l\a'{\i}nea\\
{\tt kb} \>   Tecla de retroceso\\
{\tt kB} \>   Fin de tab. retroceso\\
{\tt kC} \>   Tecla de limpiar pantalla\\
{\tt kd} \>   Tecla de bajar cursor\\
{\tt kD} \>   Tecla de borrar car\a'acter\\
         \>   en el cursor\\
{\tt ke} \>   desactivar teclado de n\a'umeros\\
{\tt kE} \>   Tecla de borrar hasta fin de l\a'{\i}nea\\
{\tt kF} \>   Tecla de scroll adelante/abajo\\
{\tt kh} \>   Tecla de regreso del cursor al inicio\\
{\tt kH} \>   Cursor home down key\\
{\tt kI} \>   Tecla de insertar car\a'acter/modo de inserci\a'on\\
{\tt kl} \>   Tecla de cursor izquierda\\
{\tt kL} \>   Tecla de borrar l\a'{\i}nea\\
{\tt kM} \>   Tecla de salir modo inserci\a'on\\
{\tt kN} \>   Tecla de siguiente p\a'agina\\
{\tt kP} \>   Tecla de p\a'agina anterior\\
{\tt kr} \>   Tecla de cursor derecha\\
{\tt kR} \>   Tecla de scroll atr\a's/arriba\\
{\tt ks} \>   Activar teclado de n\a'umeros\\
{\tt kS} \>   Tecla de borrar hasta fin de pantalla\\
{\tt kt} \>   Tecla de limpiar esta tabulaci\a'on\\
{\tt kT} \>   Tecla para poner tab. aqu\a'{\i}\\
{\tt ku} \>   Tecla de cursor arriba\\
{\tt l0} \>   Label of zeroth function key,\\
         \>   if not f0\\
{\tt l1} \>   Label of first function key,\\
         \>   if not f1\\
{\tt l2} \>   Label of first function key,\\
         \>   if not f2\\
         \>   ...  ...\\
{\tt la} \>   Label of tenth function key,\\
         \>   if not f10\\
{\tt le} \>   Cursor left one character\\
{\tt ll} \>   Move cursor to lower left corner\\
{\tt LE} \>   Cursor left \%1 characters\\
{\tt LF} \>   Turn soft labels off\\
{\tt LO} \>   Turn soft labels on\\
{\tt mb} \>   Start blinking\\
{\tt MC} \>   Clear soft margins\\
{\tt md} \>   Start bold mode\\
{\tt me} \>   End all mode like so, us, mb,\\
              md and mr\\
{\tt mh} \>   Start half bright mode\\
{\tt mk} \>   Dark mode (Characters invisible)\\
{\tt ML} \>   Set left soft margin\\
{\tt mm} \>   Put terminal in meta mode\\
{\tt mo} \>   Put terminal out of meta mode\\
{\tt mp} \>   Turn on protected attribute\\
{\tt mr} \>   Start reverse mode\\
{\tt MR} \>   Set right soft margin\\
{\tt nd} \>   Cursor right one character\\
{\tt nw} \>   Carriage return command\\
{\tt pc} \>   Padding character\\
{\tt pf} \>   Turn printer off\\
{\tt pk} \>   Program key \%1 to send string \%2\\
         \>   as if typed by user\\
{\tt pl} \>   Program key \%1 to execute string\\
         \>   \%2 in local mode\\
{\tt pn} \>   Program soft label \%1 to to show\\
         \>   string \%2\\
{\tt po} \>   Turn the printer on\\
{\tt pO} \>   Turn the printer on for \%1\\
         \>   ($<$256) bytes\\
{\tt ps} \>   Print screen contents on printer\\
{\tt px} \>   Program key \%1 to send string\\
         \>   \%2 to computer\\
{\tt r1} \>   Reset string 1, set sane modes\\
{\tt r2} \>   Reset string 2, set sane modes\\
{\tt r3} \>   Reset string 3, set sane modes\\
{\tt RA} \>   disable automatic margins\\
{\tt rc} \>   Restore saved cursor position\\
{\tt rf} \>   Reset string file name\\
{\tt RF} \>   Request for input from terminal\\
{\tt RI} \>   Cursor right \%1 characters\\
{\tt rp} \>   Repeat character \%1 for \%2 times\\
{\tt rP} \>   Padding after character sent in\\
         \>   replace mode\\
{\tt rs} \>   Reset string\\
{\tt RX} \>   Turn off XON/XOFF flow control\\
{\tt sa} \>   Set \%1 \%2 \%3 \%4 \%5 \%6 \%7 \%8\\
         \>   \%9 attributes\\
{\tt SA} \>   enable automatic margins\\
{\tt sc} \>   Save cursor position\\
{\tt se} \>   End standout mode\\
{\tt sf} \>   Normal scroll one line\\
{\tt SF} \>   Normal scroll \%1 lines\\
{\tt so} \>   Start standout mode\\
{\tt sr} \>   Reverse scroll\\
{\tt SR} \>   scroll back \%1 lines\\
{\tt st} \>   Set tabulator stop in all rows at \\
         \>   current column\\
{\tt SX} \>   Turn on XON/XOFF flow control\\
{\tt ta} \>   move to next hardware tab\\
{\tt tc} \>   Read in terminal description from \\
         \>   another entry\\
{\tt te} \>   End program that uses\\
         \>   cursor motion\\
{\tt ti} \>   Begin program that uses\\
         \>   cursor motion\\
{\tt ts} \>   Move cursor to column \%1 of\\
         \>   status line\\
{\tt uc} \>   Underline character under cursor\\
         \>   and move cursor right\\
{\tt ue} \>   End underlining\\
{\tt up} \>   Cursor up one line\\
{\tt UP} \>   Cursor up \%1 lines\\
{\tt us} \>   Start underlining\\
{\tt vb} \>   Visible bell\\
{\tt ve} \>   Normal cursor visible\\
{\tt vi} \>   Cursor invisible\\
{\tt vs} \>   Standout cursor\\
{\tt wi} \>   Set window from line \%1 to \%2\\
         \>   and column \%3 to \%4\\
{\tt XF} \>   XOFF character if not \^{}S\\
\end{tabbing}
\end{multicols}
\end{small}



\clearpage



\section{Ncurses - Introducci\'on}

Se usar\'a la siguiente terminolog\'{\i}a a lo largo de este cap\'{\i}tulo:

\begin{itemize}
  \item  ventana ({\it window}) - es una representaci\'on interna que
  contiene una imagen de una parte de la pantalla. WINDOW se define en \vdmunix{ncurses.h}. 

  \item  pantalla ({\it screen}) - es una ventana con el tama\~no de
toda la pantalla (desde el superior izquierdo al inferior
derecho). \vdmscr{Stdscr} y \vdmscr{curscr} son pantallas.
  \item  terminal - es una pantalla especial con informaci\'on sobre lo
que aparece en la pantalla actual.
  \item  variables - Las siguientes son variables y constantes
definidas en \vdmunix{ncurses.h}
    \begin{itemize}
      \item  WINDOW *curscr - pantalla actual
      \item  WINDOW *stdscr - pantalla est\'andar
      \item  int LINES - l\'{\i}neas del terminal
      \item  int COLS - columnas del terminal
      \item  bool TRUE - flag verdadero, 1
      \item  bool FALSE - flag falso, 0
      \item  int ERR - flag de error, -1
      \item  int OK - flag de correcci\'on, 0
    \end{itemize}
  \item  funciones - los argumentos que llevan son de los siguientes tipos:
    \begin{itemize}
      \item win - WINDOW*
      \item bf - bool
      \item ch - chtype
      \item str - char*
      \item chstr - chtype*
      \item fmt - char*
      \item en otro caso, int (entero)
    \end{itemize}
\end{itemize}

Normalmente un programa que usa la biblioteca ncurses se parece a esto:

\begin{tscreen}
\begin{verbatim}
    #include <ncurses.h>
    ...
    main()
    {
      ...
      initscr();
      /* Llamadas a funciones de ncurses */
      endwin();
      ...
    }
\end{verbatim}
\end{tscreen}

La inclusi\'on de \vdmunix{ncurses.h} definir\'a variables y tipos para
ncurses, tales como WINDOW y prototipos de funciones. Incluye
automaticamente \vdmunix{stdio.h}, \vdmunix{stdarg.h},
\vdmunix{termios.h} y \vdmunix{unctrl.h}.

La funci\'on \vdmfunc{initscr()} se usa para inicializar las estructuras
de datos ncurses y para leer el archivo terminfo apropiado. La memoria
se reserva. Si ocurre un error, \vdmfunc{initscr} devolver\'a ERR, en
otro caso devuelve un puntero. Adicionalmente la pantalla se borra e
inicializa. 

La funci\'on \vdmfunc{endwin()} libera todos los recursos para ncurses y
restaura los modos de terminal al estado que ten\'{\i}an antes de llamar a \vdmfunc{initscr()}. Se debe llamar antes de cualquier otra
funci\'on de la biblioteca ncurses y \vdmfunc{endwin()} debe ser llamado
antes de que su programa termine. Cuando quiere salidas por m\'as de un
terminal, puede usar \vdmfunc{newterm(...)} en lugar de \vdmfunc{initscr()}. 

Comp\'{\i}lese el programa con:

\begin{tscreen}
\begin{verbatim}
    gcc [opciones] ficheros -lncurses
\end{verbatim}
\end{tscreen}

En las opciones se incluir\'a cualquiera que precise (\vdmunix{ver
gcc(1)}). Ya que el camino a ncurses.h ha cambiado, debe poner al
menos la siguiente opci\'on:

\begin{tscreen}
\begin{verbatim}
    -I/usr/include/ncurses
\end{verbatim}
\end{tscreen}

En otro caso, no se encontrar\'an ni ncurses.h, nterm.h, termcap.h o
unctrl.h. Otras posibles opciones en Linux son:

\begin{tscreen}
\begin{verbatim}
    -O2 -ansi -Wall -m486
\end{verbatim}
\end{tscreen}

\vdmunix{O2} pide a {\tt gcc} cierta optimizaci\'on, \vdmunix{-ansi} es
 para que compile c\'odigo compatible con ANSI-C, \vdmunix{-Wall}
 imprimir\'a toda clase de avisos y \vdmunix{-m486} generar\'a c\'odigo
 optimizado para Intel 486 (aunque el c\'odigo podr\'a correr tambi\'en en
 un 386).

La librer\'{\i}a ncurses est\'a en /usr/lib/. Hay tres versiones de \'esta:
\begin{itemize}
  \item  {\bf libncurses.a} es la librer\'{\i}a normal.
  \item  {\bf libdcurses.a} es la librer\'{\i}a que permite depuraci\'on.
  \item  {\bf libpcurses.a} para an\'alisis de perfil (desde la versi\'on \ncver
         libpcurses.a ya no existe ?).
  \item  {\bf libcurses.a} es la {\it curses BSD} original, presente
  en paquetes BSD de distribuciones como la Slackware 2.1.
\end{itemize}

Las estructuras de datos para la pantalla se llaman ventanas ({\it
windows}) como se define en \vdmunix{ncurses.h}. Una ventana es como
un string de caracteres en memoria que el 
programador puede manipular sin salida al terminal. La ventana por
defecto tiene el tama\~no del terminal. Puede crear otras ventanas con
\vdmunix{newwin(...)}. 

Para actualizar el terminal f\'{\i}sico de forma \'optima, ncurses tiene otra
ventana declarada, \vdmscr{curscr}. Esto es una imagen de a qu\'e se
parece actualmente el terminal, y \vdmscr{stdscr} es
una imagen de como deber\'{\i}a parecer el terminal. La salida se efectuar\'a
cuando llame a \vdmunix{refresh()}. Ncurses entonces actualizar\'a
\vdmscr{curscr} y el
terminal f\'{\i}sico con la 
informaci\'on disponible en \vdmscr{stdscr}. Las funciones de biblioteca
usar\'an optimizaciones internas para actualizar el proceso de forma que
pueda cambiar diferentes ventanas y entonces actualizar la pantalla de
una vez de una forma \'optima.

Con las funciones ncurses  puede manipular las estructuras de datos de
las ventanas. La funciones que comienzan por {\it w} le permiten especificar una
ventana, mientras que otras afectar\'an a la ventana. Las funciones que
comienzan con {\it mv} mover\'an el cursor a la posici\'on {\it y,x} primero.

Un car\'acter tiene el tipo {\em chtype} que es de tipo entero largo sin
signo, para almacenar informaci\'on adicional sobre \'el (atributos, etc.). 

Ncurses usa la base de datos \vdmunix{terminfo}. Normalmente la base
de dtos est\'a situada en \vdmunix{/usr/lib/terminfo/} y ncurses buscar\'a
all\'{\i} para las definiciones del terminal local. Si quiere
comprobar alguna otra definici\'on para una terminal sin cambiar el
terminfo original, ponga el valor en la variable de entorno
\vdmunix{TERMINFO}. Ncurses comprobar\'a esta variable
y usar\'a las definiciones almacenadas all\'{\i} en lugar de /usr/lib/terminfo/. 

La versi\'on actual de ncurses es la \ncver (\date).

Al final del cap\'{\i}tulo encontrar\'a una tabla con una revisi\'on de las
Curses de BSD, NCurses y las Curses de SunOS 5.4. Refi\'erase a ella
cuando quiera buscar una funci\'on espec\'{\i}fica y d\'onde se encuentra implementada.



\section{Inicializaci\'on}

\begin{itemize}

  \item {\tt WINDOW *initscr()} \label{fun_initscr}\\
Esta es la primerra funci\'on que se normalmente se llama de un programa
que usa ncurses. En algunos casos es \'util para llamar a
\vdmfunc{slk\_init(int)}, \vdmfunc{filter()},
\vdmfunc{ripoffline(...)} o \vdmfunc{use\_env(bf)} antes de
\vdmfunc{initscr()}. Cuando use terminales m\'ultiples (o quiz\'as
capacidades de comprobaci\'on), puede usar \vdmfunc{newterm(...)} en lugar de
\vdmfunc{initscr()}. 

\vdmfunc{initscr()} leer\'a el archivo terminfo apropiado e inicializar\'a
la estructura de datos ncurses , reservar\'a memoria para
\vdmfunc{curscr} y pondr\'a los valores \vdmlines{LINES} y
\vdmlines{COLS} que tiene el terminal.
Devolver\'a un puntero a \vdmscr{stdscr} o ERR cuando ocurra un
error. No necesita inicializar el puntero con:
\begin{tscreen}
\begin{verbatim}
    stdscr=initscr();
\end{verbatim}
\end{tscreen}
        \vdmfunc{initscr()} har\'a esto por usted. Si el valor retornado
 es ERR, su programa debe salir debido a que ninguna funci\'on ncurses
 funcionar\'a:
\begin{tscreen}
\begin{verbatim}
    if(!(initscr())){
      fprintf(stderr,"tipo: initscr() ha fallado\n\n");
      exit (1);
    }
\end{verbatim}
\end{tscreen}

  \item {\tt SCREEN *newterm(char *tipo, FILE *outfd, FILE *infd)}
  \label{fun_newterm}\\
        Para salida por m\'ultiples terminales debe llamarse a
  \vdmfunc{newterm(...)} por cada uno de aquellos que pretenda
  controlar con ncurses, en lugar de llamar a \vdmfunc{initscr()}. El
  argumento \vdmarg{tipo} es el nombre del terminal, tal como aparece
  en la variable de entorno \$TERM (ansi, xterm, vt100, etc\'etera). El
  argumento \vdmarg{outfd} es el puntero de salida, y el \vdmarg{infd}
  es el de entrada. Debe llamarse a \vdmfunc{endwin()} por cada
  terminal abierto con \vdmfunc{newterm(...)}.

  \item {\tt SCREEN *set\_term(SCREEN *nueva)} \label{fun_set_term}\\
        Com \vdmfunc{set\_term(SCREEN)} podemos cambiar de
        terminal. Todas las funciones posteriores actuar\'an sobre el
        terminal seleccionado.

  \item {\tt int endwin()} \label{fun_endwin}\\
        \vdmfunc{endwin()} realiza labores de limpieza, restaura el
        modo del terminal al estado que ten\'{\i}a antes de llamar a
        \vdmfunc{initscr()} y lleva el cursor a la esquina inferior
        izquierda. No olvide cerrar todas las ventanas antes de llamar
        a esta funci\'on para finalizar su aplicaci\'on.

	Una llamada adicional a \vdmfunc{refresh()} despu\'es de
        \vdmfunc{endwin()} restaurar\'a el terminal al estado que
        tuviera antes de llamar a \vdmfunc{initscr()} (modo visual);
        en otro caso ser\'a limpiado (modo no visual).

  \item {\tt int isendwin()} \label{fun_isendwin}\\
        Devuelve TRUE si \vdmfunc{endwin()} y \vdmfunc{refresh()} han
        sido ejecutadas ya. En otro caso devolver\'a FALSE.


  \item {\tt void delscreen(SCREEN* pantalla)} \label{fun_delscreen}\\
        Tras llamar a \vdmfunc{endwin()}, ll\'amese a
        \vdmfunc{delscreen(SCREEN)} para liberar los recursos, cuando
        la pantalla del argumento ya no se necesite.
        \noteni
\end{itemize}




\section{Ventanas}

Las ventanas se pueden crear, borrar, mover, copiar, duplicar y m\'as.

\begin{itemize}
  \item {\tt WINDOW *newwin(nlineas, ncols, iniy, inix)} \label{fun_newwin}\\
        \vdmarg{iniy} e \vdmarg{inix} son las coordenadas de la
        esquina superior izquierda de la ventana. \vdmarg{nlineas} es
        un entero con el n\'umero de l\'{\i}neas, y \vdmarg{ncols} es otro
        entero con el n\'umero de columnas.

        \begin{figure}
          \caption{Ncurses - esquema de newwin} \label{fig_newwin}
          \begin{center}
            \input{newwin.tex}
          \end{center}
        \end{figure}

\begin{tscreen}
\begin{verbatim}
    WINDOW *miventana;
    miventana=newwin(10,60,10,10);
\end{verbatim}
\end{tscreen}

       La esquina superior izquierda de nuestra ventana queda en la
       l\'{\i}nea y columna 10; y tiene 10 l\'{\i}neas y 60 columnas. Si
       \vdmarg{nlineas} fuera cero, la ventana tendr\'{\i}a $LINEAS-iniy$
       filas. De la misma manera, tendremos $COLS-inix$ columnas si
       \vdmarg{ncols} vale cero.

       Cuando llame a \vdmfunc{newwin(...)} con todos los argumentos a
       cero:
\begin{tscreen}
\begin{verbatim}
    WINDOW *miventana;
    miventana=newwin(0,0,0,0);
\end{verbatim}
\end{tscreen}
       la ventana as\'{\i} creada tendr\'a el tama\~no de la pantalla.

       Con la ayuda de \vdmlines{LINES} y \vdmlines{COLS} podemos
       abrir ventanas en medio de la pantalla, con el c\'odigo siguiente:

\begin{tscreen}
\begin{verbatim}
    #define MILINEA (int) ((LINES-22)/2)
    #define MICOL ((COLS-70)/2)
    #define MISLINEAS 22
    #define MISCOLS  70
    ...
    WINDOW *vent;
    ...
    if(!(initscr())){
      fprintf(stderr,"tipo: initscr() ha fallado\n\n");
      exit(1);
    }
    ...
    if ((LINES<22)||(COLS<70)){
      fprintf(stderr,"pantalla demasiado peque~na\n\n");
      endwin(); exit (1);
    }
    win=newwin(MISLINEAS,MISCOLS,MILINEA,MICOL);
    ...
\end{verbatim}
\end{tscreen}

        Esto abrir\'a una ventana de 22 l\'{\i}neas y 70 columnas en medio de
        la pantalla. Comprueba antes que quepa. En la consola de Linux
        tenemos 25 o m\'as l\'{\i}neas, y 80 o m\'as columnas, pero en los {\it
        xterms} este no es el caso, pues son libremente dimensionables.

        Alternativamente podemos usar \vdmlines{LINES} y
        \vdmlines{COLS} para adaptar las ventanas al tama\~no de la
        pantalla:

\begin{tscreen}
\begin{verbatim}
    #define MISFILAS   (int) (LINES/2+LINES/4)
    #define MISCOLS   (int) (COLS/2+COLS/4)
    #define FILAIZ  (int) ((LINES-MISFILAS)/2)
    #define COLIZ  (int) (((COLS-2)-MISCOLS)/2)
    #define FILADR (int) (FILAIZ)
    #define COLDR (int) (FILAIZ+2+MISCOLS)
    #define VCOLS    (int) (MISCOLS/2)
    ...
    WINDOW *ventizq, *ventder;
    ...
    ventizq=newwin(MISFILAS, VCOLS, FILAIZ, COLIZ);
    ventder=newwin(MISFILAS, VCOLS, FILADR, COLDR);
    ...
\end{verbatim}
\end{tscreen}

V\'ease \vdmunix{screen.c} en el directorio de ejemplos para m\'as detalle.

  \item {\tt int delwin(ventana)} \label{fun_delwin}\\
        Borra la ventana \vdmarg{ventana}. Cuando hay subventanas
        dentro, las borra antes. Adem\'as libera todos los recursos que
        ocupe la ventana. Y Borra todas las ventanas abiertas antes de
        llamar a \vdmfunc{endwin()}.

  \item {\tt int mvwin(ventana, by, bx)} \label{fun_mvwin}\\
        Esta funci\'on mueve la ventana a las coordenadas
        (\vdmarg{by,bx}). Si esto implica mover la ventana m\'as all\'a de
        los extremos de la pantalla, no se hace nada y se devuelve ERR.

  \item {\tt WINDOW *subwin(venorig, nlineas, ncols, iniy, inix)} \label{fun_subwin}\\
        Devuelve una subventana interior a \vdmarg{venorig}. Cuando
        cambie una de las dos ventanas (la subventana o la otra), este
        cambio ser\'a reflejado en ambas. Llame a
        \vdmfunc{touchwin(venorig)} antes del siguiente \vdmfunc{refresh()}.

        \vdmarg{inix} e \vdmarg{iniy} son relativos a la pantalla, no
        a la ventana \vdmarg{venorig}.

  \item {\tt WINDOW *derwin(venorig, nlineas, ncols, iniy, inix)} \label{fun_derwin}\\
        Es parecida a la anterior funci\'on, solo que ahora los
        par\'ametros \vdmarg{iniy} e \vdmarg{inix} son relativos a la
        ventana \vdmarg{venorig} y no a la pantalla.

  \item {\tt int mvderwin(ventana, y, x)} \label{fun_mvderwin}\\
        Mueve la \vdmarg{ventana} deltro de la ventana madre.
        \noteni

  \item {\tt WINDOW *dupwin(ventana)} \label{fun_dupwin}\\
        Duplica la \vdmarg{ventana}.

  \item {\tt int syncok(ventana, bf)} \label{fun_syncok}\\
        {\tt void wsyncup(ventana)} \label{fun_wsyncup}\\
        {\tt void wcursyncup(ventana)} \label{fun_wcursyncup}\\
        {\tt void wsyncdown(ventana)} \label{fun_wsyncdown}\\
        \noteni

  \item {\tt int overlay(vent1, vent2)} \label{fun_overlay}\\
        {\tt int overwrite(vent1, vent2)} \label{fun_overwrite}\\
        \vdmfunc{overlay(...)} copia todo el texto de \vdmarg{vent1} a
        \vdmarg{vent2} sin copiar los blancos. La funci\'on
        \vdmfunc{overwrite(...)} hace lo mismo pero adem\'as copia los blancos.

  \item {\tt int copywin(vent1, vent2, sminfil, smincol, dminfil, dmincol,}\\
        {\tt dmaxfil, dmaxcol, overlay)} \label{fun_copywin}\\
        Es similar a \vdmfunc{overlay(...)} y
        \vdmfunc{overwrite(...)}, pero proporciona control sobre la
        regi\'on de la ventana a copiar.
\end{itemize}




\section{Salida}

\begin{itemize}
  \item {\tt int addch(ch)} \label{fun_addch}\\
        {\tt int waddch(ven, ch)} \label{fun_waddch}\\
        {\tt int mvaddch(y, x, ch)} \label{fun_mvaddch}\\
        {\tt int mvwaddch(ven, y, x, ch)} \label{fun_mvwaddch}\\
        Estas funciones se usan para enviar caracteres a la ventana. Para
        verlos efectivamente habr\'a que llamar a
        \vdmfunc{refresh()}. Con las funciones \vdmfunc{addch()} y
        \vdmfunc{waddch()} se env\'{\i}a el caracter a la ventana actual o
        a la especificada, respectivamente. Las funciones
        \vdmfunc{mvaddch()} y \vdmfunc{mvwaddch()} hacen lo mismo pero
        previamente mueven el cursor a la posici\'on indicada.

  \item {\tt int addstr(str)} \label{fun_addstr}\\
        {\tt int addnstr(str, n)} \label{fun_addnstr}\\
        {\tt int waddstr(ven, str)} \label{fun_waddstr}\\
        {\tt int waddnstr(ven, str, n)} \label{fun_waddnstr}\\
        {\tt int mvaddstr(y, x, str)} \label{fun_mvaddstr}\\
        {\tt int mvaddnstr(y, x, str, n)} \label{fun_mvaddnstr}\\
        {\tt int mvwaddstr(ven, y, x, str)} \label{fun_mvwaddstr}\\
        {\tt int mvwaddnstr(ven, y, x, str, n)} \label{fun_mvwaddnstr}\\

        Estas funciones escriben un string en la ventana y son
        equivalentes a series de llamadas a \vdmfunc{addch()},
        etc. \vdmarg{str} debe ser terminado en el car\'acter nulo
        (\verb+\+0). Las funciones con par\'ametro \vdmarg{ven}
        especifican la ventana donde escribir. Si no aparece se env\'{\i}a
        a la ventana est\'andar (stdscr). Las funciones con par\'ametro
        \vdmarg{n} indican cu\'antos caracteres escribir; y si
        \vdmarg{n} vale -1, se escribir\'an todos los caracteres del string.

  \item {\tt int addchstr(chstr)} \label{fun_addchstr}\\
        {\tt int addchnstr(chstr, n)} \label{fun_addchnstr}\\
        {\tt int waddchstr(ven, chstr)} \label{fun_waddchstr}\\
        {\tt int waddchnstr(ven, chstr, n)} \label{fun_waddchnstr}\\
        {\tt int mvaddchstr(y, x, chstr)} \label{fun_mvaddchstr}\\
        {\tt int mvaddchnstr(y, x, chstr, n)} \label{fun_mvaddchnstr}\\
        {\tt int mvwaddchstr(ven, y, x, chstr)} \label{fun_mvwaddchstr}\\
        {\tt int mvwaddchnstr(ven, y, x, chstr, n)} \label{fun_mvwaddchnstr}\\
        Estas funciones copian \vdmarg{chstr} a la ventana. La
        posici\'on inicial es la del cursor. Las funciones con par\'ametro
        \vdmarg{n} escriben esos \vdmarg{n} caracteres del string; y
        si vale -1 se escribir\'an todos. El cursor no es movido ni se
        comprueban caracteres de control. Estas funciones son m\'as
        r\'apidas que las \vdmfunc{addstr(...)}. El par\'ametro
        \vdmarg{chstr} es un puntero a un array de tipo {\tt chtype}.

  \item {\tt int echochar(ch)} \label{fun_echochar}\\
        {\tt int wechochar(vent, ch)} \label{fun_wechochar}\\
        Es lo mismo que llamar a \vdmfunc{addch} o \vdmfunc{waddch}
        seguido de una llamada al \vdmfunc{refresh()}.
         
\end{itemize}




\subsection{Salida con Formato}

\begin{itemize}
  \item {\tt int printw(fmt, ...)} \label{fun_printw}\\
        {\tt int wprintw(win, fmt, ...)} \label{fun_wprintw}\\
        {\tt int mvprintw(y, x, fmt, ...)} \label{fun_mvprintw}\\
        {\tt int mvwprintw(win, y, x, fmt, ...)} \label{fun_mvwprintw}\\
        {\tt int vwprintw(win, fmt, va\_list)} \label{fun_vwprintw}\\
        Estas funciones se corresponden con \vdmfunc{printf(...)} y su
        formas asociadas.

        El paquete \vdmfunc{printf(...)} se usa para formatear salidas. Puede
        definir una cadena de salida e incluir variables de diferentes
        tipos en ella. Vea la \secref{sec_formout} para m\'as informaci\'on. 

        Para usar la funci\'on \vdmfunc{vwprintw(...)} tiene que
        incluirse en el programa la cabecera \vdmunix{varargs.h}.
\end{itemize}




\subsection{Inserción de Caracteres/Líneas}

\begin{itemize}
  \item {\tt int insch(c)} \label{fun_insch}\\
        {\tt int winsch(win, c)} \label{fun_winsch}\\
        {\tt int mvinsch(y,x,c)} \label{fun_mvinsch}\\
        {\tt int mvwinsch(win,y,x,c)} \label{fun_mvwinsch}\\
        El carácter \vdmarg{ch} se inserta a la izquierda del cursor y
        los demás son movidos una posición a la derecha. El carácter
        del extremo derecho de la línea puede perderse.

  \item {\tt int insertln()} \label{fun_insertln}\\
        {\tt int winsertln(win)} \label{fun_winsertln}\\
        Inserta una línea en blanco sobre la actual (la línea más
        inferior se perderá).

  \item {\tt int insdelln(n)} \label{fun_insdelln}\\
        {\tt int winsdelln(win, n)} \label{fun_winsdelln}\\
        Para valores positivos de \vdmarg{n} estas funciones
        insertarán n líneas sobre el cursor en la ventana
        seleccionada, con lo que las n líneas inferiores se
        perderán. Cuando \vdmarg{n} es negativo, se borrarán n líneas
        bajo el cursor y las inferiores serán movidas hacia arriba.

  \item {\tt int insstr(str)} \label{fun_insstr}\\
        {\tt int insnstr(str, n)} \label{fun_insnstr}\\
        {\tt int winsstr(win, str)} \label{fun_winsstr}\\
        {\tt int winsnstr(win, str, n)} \label{fun_winsnstr}\\
        {\tt int mvinsstr(y, x, str)} \label{fun_mvinsstr}\\
        {\tt int mvinsnstr(y, x, str, n)} \label{fun_mvinsnstr}\\
        {\tt int mvwinsstr(win, y, x, str)} \label{fun_mvwinsstr}\\
        {\tt int mvwinsnstr(win, y, x, str, n)} \label{fun_mvwinsnstr}\\
        Estas funciones insertarán la cadena \vdmarg{str} en la línea
        actual a la izquierda del cursor. Los caracteres de la derecha
        de éste son movidas a la derecha y se perderán si superan el
        final de la línea. La posición del cursor no cambia.

        \vdmarg{y} y \vdmarg{x} son las coordenadas a las que el
        cursor será movido antes de insertar la cadena, y \vdmarg{n}
        es el número de caracteres a insertar (cuando valga 0, se
        insertará la cadena completa).

\end{itemize}



\subsection{Borrado de Caracteres/Líneas}

\begin{itemize}
  \item {\tt int delch()} \label{fun_delch}\\
        {\tt int wdelch(win)} \label{fun_wdelch}\\
        {\tt int mvdelch(y, x)} \label{fun_mvdelch}\\
        {\tt int mvwdelch(win, y, x)} \label{fun_mvwdelch}\\
        Estas funciones borran el carácter del cursor y mueven los
        restantes caracteres que estén a la derecha, una posición a la
        izquierda.

        \vdmarg{y} y \vdmarg{x} son las coordenadas en las que se
        pondrá el cursor previamente al borrado.

  \item {\tt int deleteln()} \label{fun_deleteln}\\
        {\tt int wdeleteln(win)} \label{fun_wdeleteln}\\
        Estas funciones borran la línea del cursor y mueven las
        restantes líneas inferiores una posición más arriba.

\end{itemize}




\subsection{Cajas y Líneas}

\begin{itemize}
  \item {\tt int border(ls, rs, ts, bs, tl, tr, bl, br)} \label{fun_border}\\
        {\tt int wborder(win, ls, rs, ts, bs, tl, tr, bl, br)} \label{fun_wborder}\\
        {\tt int box(win, vert, hor)} \label{fun_box}\\
        Sirven para dibujar un borde en los lados de una ventana (bien
        sea la \vdmscr{stdscr} o el parámetro \vdmarg{win}). En la
        siguiente tabla se aprecian los caracteres y sus valores por
        defecto cuando se llama a \vdmfunc{box(...)}. En la figura
        puede verse la posición de los caracteres en una caja.

\begin{table}
  \caption{Ncurses - caracteres del borde}\label{tab_borderch}
  \begin{center}
    \begin{tabular}{c|l|l}
    {\bf Carácter} &  {\bf Posición} &  {\bf Defecto} \\ \hline
    tl &  superior izq.     &  ACS\_ULCORNER \\
    ts &  lado superior     &  ACS\_HLINE    \\
    tr &  superior der.    &  ACS\_URCORNER \\
    ls &  lado izquierdo    &  ACS\_VLINE    \\
    rs &  lado derecho   &  ACS\_VLINE    \\
    bl &  inferior izq.  &  ACS\_LLCORNER \\
    bs &  lado inferior  &  ACS\_HLINE    \\
    br &  inferior der. &  ACS\_LRCORNER \\
    rt &  centro der.    &  ACS\_RTEE     \\
    lt &  centro izq.     &  ACS\_LTEE     \\
    tt &  centro sup.      &  ACS\_TTEE     \\
    bt &  centro inf.   &  ACS\_BTEE     \\
    \end{tabular}
  \end{center}
\end{table}

\begin{figure}
  \caption{Ncurses - caracteres de caja} \label{fig_boxbic}
  \begin{center}
    \input{boxpic.tex}
  \end{center}
\end{figure}

  \item {\tt int vline(ch, n)} \label{fun_vline}\\
        {\tt int wvline(win, ch, n)} \label{fun_wvline}\\
        {\tt int hline(ch, n)} \label{fun_hline}\\
        {\tt int whline(win, ch, n)} \label{fun_whline}\\
        Estas funciones dibujan una línea vertical u horizontal a
        partir de la posición del cursor. El carácter \vdmarg{ch} esl
        el que se utiliza, y \vdmarg{n} es el número de caracteres
        deseados. La posición del cursor no cambia.
\end{itemize}



\subsection{Carácter de Fondo}

\begin{itemize}
  \item {\tt void bkgdset(ch)} \label{fun_bkgdset}\\
        {\tt void wbkgdset(win, ch)} \label{fun_wbkgdset}\\
Fija el carácter y atributo para la pantalla o una ventana. El
        atributo en \vdmarg{ch} será ORed con cada carácter no blanco
        en la ventana. El fondo es entonces parte de la venana y no cambia con desplazamientos ni con las salidas.

  \item {\tt int bkgd(ch)} \label{fun_bkgd}\\
        {\tt int wbkgd(win, ch)} \label{fun_wbkgd}\\
        Cambia el carácter de fondo y el atributo a \vdmarg{ch}. 
\end{itemize}

\section{Entrada}

\begin{itemize}
  \item {\tt int getch()} \label{fun_getch}\\
        {\tt int wgetch(win)} \label{fun_wgetch}\\
        {\tt int mvgetch(y, x)} \label{fun_mvgetch}\\
        {\tt int mvwgetch(win, y, x)} \label{fun_mvwgetch}\\
        \vdmfunc{getch()} leerá la entrada del terminal de una forma
        que dependerá
        si el modo de retardo (delay) está activo no. Si delay está
        activo, \vdmfunc{getch()} esperará hasta que se pulse una tecla, en otro
        caso devolverá la tecla del buffer de entrada o ERR si el
        buffer está vacío. \vdmfunc{mvgetch(...)} y
        \vdmfunc{mvwgetch(...)} moverá primero
        el cursor a la posición y,x. Las funciones \vdmarg{w} leen la entrada
        del terminal a la ventana \vdmarg{win}, \vdmfunc{getch()} y
        \vdmfunc{mvgetch(...)} del terminal asociado. 

Con \vdmfunc{keypad(...)} activado, \vdmfunc{getch()} devolverá un código definido en .h
como ,macros KEY\_* cuando se pulsa una tecla de función. Cuando se
pulsa ESCAPE (que puede ser el inicio de una tecla de función) ncurses
iniciará un temporizador de un segundo. Si el resto de las pulsaciones
no se completa en este segundo, se devuelve la tecla. En otro caso se
devuelve el valor de la tecla de función. (Si es necesario, use
\vdmfunc{notimeout()} para desactivar el temporizador de un segundo).

  \item {\tt int ungetch(ch)} \label{fun_ungetch}\\
        Will put the character \vdmarg{ch} back to the input buffer.

  \item {\tt int getstr(str)} \label{fun_getstr}\\
        {\tt int wgetstr(win, str)} \label{fun_wgetstr}\\
        {\tt int mvgetstr(y, x, str)} \label{fun_mvgetstr}\\
        {\tt int mvwgetstr(win, y, x, str)} \label{fun_mvwgetstr}\\
        {\tt int wgetnstr(win, str, n)} \label{fun_wgetnstr}\\
        Estas funciones realizarán series de llamadas a
        \vdmfunc{getch()} hasta que se reciba un carácter de fin de
        línea. Los caracteres se guardan en \vdmarg{str} (por lo que
        no olvide reservar memoria antes de llamar a estas
        funciones). Si el eco está activo, la cadena es reflejada en
        pantalla, y las teclas {\it kill} y {\it delete} serán
        interpretadas (utilice la función \vdmfunc{noecho} para
        desactivar el eco).

  \item {\tt chtype inch()} \label{fun_inch}\\
        {\tt chtype winch(win)} \label{fun_winch}\\
        {\tt chtype mvinch(y, x)} \label{fun_mvinch}\\
        {\tt chtype mvwinch(win, y, x)} \label{fun_mvwinch}\\
Estas funciones devuelven un carácter de una pantalla o ventana. Como
        el tipo del valor devuelto es chtype se incluye información de
        atributo. Esta información se puede extraer del carácter
        usando las constantes A\_* constants (ver \tabref{tab_attr}).

  \item {\tt int instr(str)} \label{fun_instr}\\
        {\tt int innstr(str, n)} \label{fun_innstr}\\
        {\tt int winstr(win, str)} \label{fun_winstr}\\
        {\tt int winnstr(win, str, n)} \label{fun_winnstr}\\
        {\tt int mvinstr(y, x, str)} \label{fun_mvinstr}\\
        {\tt int mvinnstr(y, x, str, n)} \label{fun_mvinnstr}\\
        {\tt int mvwinstr(win, y, x, str)} \label{fun_mvwinstr}\\
        {\tt int mvwinnstr(win, y, x, str, n)} \label{fun_mvwinnstr}\\
        Return a character string from the screen or a window.
        \noteni

  \item {\tt int inchstr(chstr)} \label{fun_inchstr}\\
        {\tt int inchnstr(chstr, n)} \label{fun_inchnstr}\\
        {\tt int winchstr(win, chstr)} \label{fun_winchstr}\\
        {\tt int winchnstr(win, chstr, n)} \label{fun_winchnstr}\\
        {\tt int mvinchstr(y, x, chstr)} \label{fun_mvinchstr}\\
        {\tt int mvinchnstr(y, x, chstr, n)} \label{fun_mvinchnstr}\\
        {\tt int mvwinchstr(win, y, x, chstr)} \label{fun_mvwinchstr}\\
        {\tt int mvwinchnstr(win, y, x, chstr, n)} \label{fun_mvwinchnstr}\\
        Estas funciones devuelven una cadena de carateres de la
        pantalla o ventana. En la cadena se incluye una información de
        atributo por cada carácter.
        \notenie{lib\_inchstr no incluida en la librería ncurses}
\end{itemize}




\subsection{Entrada con Formato}

\begin{itemize}
  \item {\tt int scanw(fmt, ...)} \label{fun_scanw}\\
        {\tt int wscanw(win, fmt, ...)} \label{fun_wscanw}\\
        {\tt int mvscanw(y, x, fmt, ...)} \label{fun_mvscanw}\\
        {\tt int mvwscanw(win, y, x, fmt, ...)} \label{fun_mvwscanw}\\
        {\tt int vwscanw(win, fmt, va\_list)} \label{fun_vwscanw}\\
        Estas son similares a \vdmfunc{scanf(...)} (vea la
        \secref{sec_formin}). \vdmfunc{wgetstr(...)} se llama y el
        resultado se usa como una entrada para scan.
\end{itemize}





\section{Opciones}


\subsubsection{Opciones de Salida}

\begin{itemize}
  \item {\tt int idlok(win, bf)} \label{fun_idlok}\\
        {\tt void idcok(win, bf)} \label{fun_idcok}\\
        Activan o desactivan las características de inserción/borrado
        del terminal a la ventana; para líneas con
        \vdmfunc{idlok(...)} y para caracteres con \vdmfunc{idcok(...)}.
        \notenib{\vdmfunc{idcok(...)}}

  \item {\tt void immedok(win, bf)} \label{fun_immedok}\\
        Si es TRUE, cada cambio en la ventana \vdmarg{win} supondrá un
        refresco de la pantalla física. Esto puede decrementar el
        rendimiento de un programa, por lo que el valor por defecto es
        FALSE.
        \noteni

  \item {\tt int clearok(win, bf)} \label{fun_clearok}\\
        Si \vdmarg{bf} es TRUE, la siguiente llamada a
        \vdmfunc{wrefresh(win)} limpiará la pantalla y la redibujará
        totalmente (como cuando pulsamos CTRL-L en el editor {\it vi}).

  \item {\tt int leaveok(win, bf)} \label{fun_leaveok}\\
        El comportamiento normal de ncurses deja el cursor físico en
        el mismo lugar antes del último refresco de la pantalla. Los
        programas que no usan el cursor pueden ejecutar esta función
        con el valor TRUE, y evitar el tiempo que requiere mover el
        cursor. Además, ncurses intentará hacer que el cursor no sea visible.

  \item {\tt int nl()} \label{fun_nl}\\
        {\tt int nonl()} \label{fun_nonl}\\
        Controla la traducción del fin de línea. Cuando se activa con
        la función \vdmfunc{nl()}, traducirá el fin de línea a un
        retorno de carro seguido de una alimentación de línea. Si lo
        ponemos a OFF con la función \vdmfunc{nonl()}, se evitará esta
        traducción lo que también implica un movimiento del cursor más
        rápido.
\end{itemize}



%% CBALLARD-1-START
\subsection{Opciones en la entrada}

\begin{itemize}
\item {\tt int keypad(win, bf)} \label{fun_keypad}\\
  Si vale TRUE, habilita el teclado num\'erico de la terminal del
  usuario cuando est\'a esperando entrada de datos.  Ncurses retornar\'a
  el c\'odigo de tecla que se define en \vdmunix{ncurses.h} como KEY\_*
  para cada tecla de funci\'on y para las teclas con las flechas.  Esto
  es muy \'util para un teclado de PC porque se puede de esta manera
  disponer entonces del bloqueo num\'erico y de las flechas.

  \begin{figure}
%          \caption{} \label{}
    \begin{center}
      \input{keypad.tex}
    \end{center}
  \end{figure}
        
\item {\tt int meta(win, bf)} \label{fun_meta}\\
  Si est\'a en TRUE, los c\'odigos de teclas que retorna \vdmfunc{getch()}
  ser\'an de 8 bits (esto es, no se le pondr\'a a cero su bit m\'as alto).
  
\item {\tt int cbreak()} \label{fun_cbreak}\\
  {\tt int nocbreak()} \label{fun_nocbreak}\\
  {\tt int crmode()} \label{fun_crmode}\\
  {\tt int nocrmode()} \label{fun_nocrmode}\\
  \vdmfunc{cbreak()} y \vdmfunc{nocbreak()} enciende y apaga,
  respectivamente el modo CBREAK de la terminal.  Cuando CBREAK est\'a
  encendido, cualquier car\'acter le\'{\i}do a la entrada estar\'a disponible
  inmediatamente para el programa; mientras que si est\'a apagado se
  almacenar\'a en un b\'ufer hasta que aparezca un car\'acter cambio de
  l\'{\i}nea (\emph{newline}).  \notenm{\vdmfunc{crmode()} y
    \vdmfunc{nocrmode()} existen s\'olo por razones de compatibilidad
    con versiones anteriores, por favor no los utilice.}

\item {\tt int raw()} \label{fun_raw}\\
  {\tt int noraw()} \label{fun_noraw}\\
  Enciende y apaga, respectivamente, el modo RAW.  Este modo es igual
  al CBREAK, excepto por el hecho que en modo RAW no se procesa a los
  car\'acteres especiales.
  
\item {\tt int echo()} \label{fun_echo}\\
  {\tt int noecho()} \label{fun_noecho}\\
  Use \vdmfunc{echo()} para obtener eco en pantalla de los car\'acteres
  tecleados por el usuario a la entrada, y \vdmfunc{noecho()} para que
  no se vea dicho eco.
  
\item {\tt int halfdelay(t)} \label{fun_halfdelay}\\
  Como el caso de \vdmfunc{cbreak()} pero con una espera de \vdmarg{t}
  segundos.
  
\item {\tt int nodelay(win, bf)} \label{fun_nodelay}\\
  Con TRUE como argumento, configura la terminal en modo inmediato
  (\emph{non-blocking}). \vdmfunc{getch()} retornar\'a ERR si no hay
  car\'acteres ya disponibles a la entrada. Si se le da FALSE como
  argumento, \vdmfunc{getch()} esperar\'a hasta que se oprima una tecla.
  
\item {\tt int timeout(t)} \label{fun_timeout}\\
  {\tt int wtimeout(win, t)} \label{fun_wtimeout}\\
  Se recomienda utilizar estas funciones en lugar de
  \vdmfunc{halfdelay(t)} y \vdmfunc{nodelay(win,bf)}. El resultado de
  \vdmfunc{getch()} depende del valor de \vdmarg{t}. Si \vdmarg{t} es
  positivo, la lectura se detiene durante \vdmarg{t} milisegundos, si
  \vdmarg{t} es cero, no se realiza ninguna detenci\'on, y cuando
  \vdmarg{t} es negativo el programa se detiene hasta que haya
  car\'acteres disponibles a la entrada.

\item {\tt int notimeout(win, bf)} \label{fun_notimeout}\\
  Si \vdmarg{bf} es TRUE, \vdmfunc{getch()} utilizar\'a un contador
  regresivo especial (con un lapso de un segundo) para interpretar y
  aceptar las secuencias que comienzan con teclas como ESCAPE, etc.

\item {\tt int typeahead(fd)} \label{fun_typeahead}\\
  Si \vdmarg{fd} es -1 no se realizar\'a control para saber si hay
  car\'acteres en espera (\emph{typeahead}); sino, cuando ncurses
  realice dicho control utilizar\'a el descriptor de fichero \vdmarg{fd}
  en lugar de \vdmunix{stdin}.

\item {\tt int intrflush(win, bf)} \label{fun_intrflush}\\
  Cuando se habilita con \vdmarg{bf} en TRUE, entonces cualquiera de
  las teclas de interrupci\'on que se oprima (quit, break, \ldots)
  ocasionar\'a que se exhiban todos los car\'acteres pendientes de salida
  en la cola del manejador de la tty.
  
\item {\tt void noqiflush()} \label{fun_noqiflush}\\
  {\tt void qiflush()} \label{fun_qiflush}\\
  \noteni
\end{itemize}




\subsection{Atributos de la terminal}

\begin{itemize}
\item {\tt int baudrate()} \label{fun_baudrate}\\
  Retorna la velocidad de la terminal en bps (bits per second).
  
\item {\tt char erasechar()} \label{fun_erasechar}\\
  Retorna el actual car\'acter que sirve para borrar (\emph{erase}).
  
\item {\tt char killchar()} \label{fun_killchar}\\
  Retorna el car\'acter actual para "<matar"> la l\'{\i}nea actual
  (\emph{kill}).
  
\item {\tt int has\_ic()} \label{fun_has_ic}\\
  {\tt int has\_il()} \label{fun_has_il}\\
  \vdmfunc{has\_ic()} retorna TRUE si la terminal tiene la capacidad
  de insertar/borrar de a un car\'acter
  \vdmfunc{has\_il()} retorna TRUE cuando la
  terminal tiene la capacidad de insertar/borrar de a l\'{\i}neas.  Si no
  fuera as\'{\i}, las funciones retornan ERR.  \noteni
  
\item {\tt char *longname()} \label{fun_longname}\\
  Retorna un apuntador que nos permite acceder a la descripci\'on de la
  terminal actual.
  
\item {\tt chtype termattrs()} \label{fun_termattrs}\\
  \noteni
  
\item {\tt char *termname()} \label{fun_termname}\\
  Retorna el contenido de la variable del entorno de usuario TERM.
  \noteni
\end{itemize}




\subsection{¿C\'omo se usa?}

Hasta ahora hemos visto las opciones de las ventanas y los modos de
las terminales, ya es hora de describir c\'omo se utiliza todo esto.

En Linux lo primero es habilitar el teclado num\'erico.  Esto permitir\'a
la utilizaci\'on de las teclas de las flechas y el teclado num\'erico.

\begin{tscreen}
\begin{verbatim}
    keypad(stdscr,TRUE);
\end{verbatim}
\end{tscreen}

Ahora bien, existen dos maneras fundamentales de esperar entradas
desde el teclado.

\begin{enumerate}
\item El progrma quiere que el usuario oprima una tecla y luego en
  funci\'on de la tecla seleccionada se elegir\'a el procedimiento
  apropiado.  (Por ejemplo, \texttt{"Oprima 't' para terminar"} y
  luego el programa aguarda una \textit{t})
\item El programa quiere que el usuario escriba una cadena de
  car\'acteres dentro de una m\'ascara exhibida en la pantalla.  Por
  ejemplo, un nombre de directorio, o una direcci\'on postal en una base
  de datos.
\end{enumerate}

Para el primer caso, utilizaremos las siguientes opciones y modos:

\begin{tscreen}
\begin{verbatim}
    char c;

    noecho();
    timeout(-1);
    nonl();
    cbreak();
    keypad(stdscr,TRUE);
    while(c=getch()){
      switch(c){
        case 't': funcion_de_terminaci\'on();
        default:  break;
      }
   }
\end{verbatim}
\end{tscreen}

El programa se detiene hasta que se oprime una tecla.  Si la tecla fue
\textit{s} llamamos a nuestra funci\'on de terminaci\'on, sino, esperamos
por otra tecla.

La construcci\'on \texttt{switch} puede expandirse hasta llenar nuestras
necesidades de procesamiento de entradas.  Utilice las macros
\texttt{KEY\_}* para leer las teclas especiales, por ejemplo:

\begin{tscreen}
\begin{verbatim}
    KEY_UP      KEY_RIGHT    KEY_A1    KEY_B2    KEY_C1
    KEY_DOWN    KEY_LEFT     KEY_A3              KEY_C3
\end{verbatim}
\end{tscreen}

\noindent le servir\'an para leer las teclas de movimiento de cursor.

Si desea ver el contenido de un fichero, deber\'a utilizar un c\'odigo
como el que sigue:

\begin{tscreen}
\begin{verbatim}
    int sigo=TRUE;
    char c;
    enum{ARRIBA,ABAJO,DERECHA,IZQUIERDA};

    noecho();
    timeout(-1);
    nonl();
    cbreak();
    keypad(stdscr,TRUE);
    while(sigo==TRUE){
      c=getch();
      switch(c){
        case KEY_UP:
        case 'a':
        case 'A': scroll_s(ARRIBA);
                  break;
        case KEY_DOWN:
        case 'b':
        case 'B': scroll_s(ABAJO);
                  break;
        case KEY_LEFT:
        case 'i':
        case 'I': scroll_s(IZQUIERDA);
                  break;
        case KEY_RIGHT
        case 'd':
        case 'D': scroll_s(DERECHA);
                  break;
        case 't':
        case 'T': sigo=FALSE;
        default:  break;
      }
   }
\end{verbatim}
\end{tscreen}

Para el segundo caso, s\'olo necesitamos ejecutar \vdmfunc{echo()} y
entonces los car\'acteres tecleados por el usuario se escribir\'an en la
pantalla.  Para poner los car\'acteres en alguna posici\'on deseada en
particular, utilice \vdmfunc{move(\ldots)} o \vdmfunc{wmove(\ldots)}.

O sino, podemos abrir una ventana con una m\'ascara en ella (por ejemplo
podemos elegir colores distintos para resaltar la m\'ascara) y solicitar
al usuario que ingrese una cadena:

\begin{tscreen}
\begin{verbatim}
    WINDOW *maskwin;
    WINDOW *mainwin;
    char *ptr=(char *)malloc(255);
    ...
      mainwin=newwin(3,37,9,21);
      maskwin=newwin(1,21,10,35);
      ...
      werase(mainwin);
      werase(maskwin);
      ...
      box(mainwin,0,0);
      mvwaddstr(mainwin,1,2,"Cadena a ingresar: ");
      ...
      wnoutrefresh(mainwin);
      wnoutrefresh(maskwin);
      doupdate();
      ...
      mvwgetstr(maskwin,0,0,ptr);
      ...
      delwin(maskwin);
      delwin(mainwin);
      endwin();
      free(ptr);
\end{verbatim}
\end{tscreen}
    
Mire por favor \vdmunix{input.c} en el directorio de ejemplos, para
una mejor explicaci\'on.


\section{¿C\'omo borrar ventanas y l\'{\i}neas?}

\begin{itemize}
\item {\tt int erase()} \label{fun_erase}\\
  {\tt int werase(win)} \label{fun_werase}\\
  \vdmfunc{werase(\ldots)} y \vdmfunc{erase()} tapar\'an con espacios en
  blanco cada posici\'on de la ventana \vdmarg{win} o de
  \vdmscr{stdscr}, respectivamente.  Por ejemplo, si Ud.\@ configura
  los atributos de una ventana con ciertos colores y luego llama a
  \vdmfunc{werase()}, la ventana se colorear\'a.  He tenido algunos
  problemas con 
  \texttt{COLOR\_PAIRS} cuando defino atributos distintos a negro
  sobre blanco, as\'{\i} que termin\'e escrbiendo mi propia funci\'on para
  borrar (que accede a bajo nivel a la estructura \texttt{WINDOW}:

  \begin{tscreen}
  \begin{verbatim}
    void NewClear(WINDOW *win)
    {
    int  y,x;

     for ( y = 0 ; y <= win -> _maxy ; y++ )
       for ( x = 0 ; x <= win -> _maxx ; x++ )
         (chtype *) win-> _line[y][x] = ' '|win-> _attrs;
     win -> _curx = win -> _cury = 0;
     touchwin(win);
    }
  \end{verbatim}
  \end{tscreen}
  
  El problema es que ncurses a veces no utiliza los atributos de la
  ventana cuando limpia la pantalla.  Por ejemplo, en
  \vdmunix{lib\_clrtoeol.c}, se define a BLANK como:

  \begin{tscreen}
  \begin{verbatim}
    #define BLANK ' '|A_NORMAL
  \end{verbatim}
  \end{tscreen}
 
  as\'{\i} que los otros atributos se pierden al borrar hasta el final de
  la l\'{\i}nea.
  
\item {\tt int clear()} \label{fun_clear}\\
  {\tt int wclear(win)} \label{fun_wclear}\\
  Igual que \vdmfunc{erase()}, pero ejecuta adem\'as \vdmfunc{clearok()}
  ( la pantalla se limpiar\'a al realizarse el siguiente refresco).

\item {\tt int clrtobot()} \label{fun_clrtobot}\\
  {\tt int wclrtobot(win)} \label{fun_wclrtobot}\\
  Borra la l\'{\i}nea donde se encuentra el cursor, comenzando desde el
  car\'acter justo a la derecha del cursor, y la l\'{\i}nea debajo del
  cursor. 
  
\item {\tt int clrtoeol()} \label{fun_clrtoeol}\\
  {\tt int wclrtoeol(win)} \label{fun_wclrtoeol}\\
  Borra la l\'{\i}nea actual desde la posici\'on del cursor hasta el final.
\end{itemize}


\section{Actualizaci\'on de la imagen an la terminal}

Como ya se mencion\'o en la introducci\'on, las ventanas de ncurses son
im\'agenes en memoria.  Esto significa que cualquier cambio que se
realice en una ventana no se refleja en la pantalla f\'{\i}sica de la
terminal hasta que se efect\'ue un "<refresco">.  De esta manera se
optimiza la tarea de enviar la salida a la terminal porque se puede
realizar un mont\'on de cambios y luego, de una sola vez, llamar a
\texttt{refresh()} para que escriba la pantalla final.  Si no se
manejara de este modo, cada peque\~no cambio en la pantalla deber\'{\i}a
enviarse a la terminal, y por lo tanto perjudicar\'{\i}a la performance del
programa del usuario.

\begin{itemize}
  
\item {\tt int refresh()} \label{fun_refresh}\\
  {\tt int wrefresh(win)} \label{fun_wrefresh}\\
  \vdmfunc{refresh()} copia \vdmscr{stdscr} a la terminal y
  \vdmfunc{wrefresh(win)} copia la imagen de la ventana a
  \vdmscr{stdscr} y luego hace que \vdmscr{curscr} se vea como
  \vdmscr{stdscr}.
  
\item {\tt int wnoutrefresh(win)} \label{fun_wnoutrefresh}\\
  {\tt int doupdate()} \label{fun_doupdate}\\
  \vdmfunc{wnoutrefresh(win)} copia s\'olo la ventana \vdmarg{win} a
  \vdmscr{stdscr}.  Esto significa no se ha realizado ninguna
  actualizaci\'on de la terminal, aunque la pantalla virtual
  \vdmscr{stdscr} tiene la disposici\'on actualizada.
  \vdmfunc{doupdate()} se ocupar\'a de enviar la salida a la terminal.
  De esta manera, un programa puede cambiar varias ventanas, llamar a 
  \vdmfunc{wnoutrefresh(win)} para cada ventana y luego llamar a 
  \vdmfunc{doupdate()} para actualizar la pantalla f\'{\i}sica s\'olo una
  vez.
  
  Por ejemplo, tenemos el siguiente programa con dos ventanas.
  Procedemos a alterar ambas ventanas cambiando algunas l\'{\i}neas de
  texto.  Podemos escribir {\it changewin(win)} con
  \vdmfunc{wrefresh(win)}.

  \begin{tscreen}
  \begin{verbatim}
    main()                    changewin(WINDOW *win)
    {                         {
    WINDOW *win1,*win2;           ... /* aqu\'{\i} alteramos */
        ...                       ... /* las l\'{\i}neas */
        changewin(win1);          wrefresh(win);
        changewin(win2);      return;
        ...                   }
    }
  \end{verbatim}
  \end{tscreen}
  
  De esta manera, ncurses deber\'a actualizar dos veces la terminal, y
  por lo tanto disminuir\'a la velocidad de ejecuci\'on de nuestro
  programa.  Con \vdmfunc{doupdate()} modificamos {\it changewin(win)}
  y la funcion \texttt{main()} obteniendo una mejor performance.

\begin{tscreen}
\begin{verbatim}
    main()                    changewin(WINDOW *win)
    {                         {
    WINDOW *win1,*win2;           ... /* aqu\'{\i} alteramos */
        ...                       ... /* las l\'{\i}neas */
        changewin(win1);          wnoutrefresh(win);
        changewin(win2);      return;
        doupdate();           }
        ...
    }
\end{verbatim}
\end{tscreen}


\item {\tt int redrawwin(win)} \label{fun_redrawwin}\\
  {\tt int wredrawln(win, bline, nlines)} \label{fun_wredrawln}\\
  Utilice estas funciones cuando algunas l\'{\i}neas o toda la pantalla
  deba descartarse antes de escribir algo nuevo (puede ser por ejemplo
  cuando las l\'{\i}neas en la pantalla se han mezclado con basura, o algo
  as\'{\i}).
  
\item {\tt int touchwin(win)} \label{fun_touchwin}\\
  {\tt int touchline(win, start, count)} \label{fun_touchline}\\
  {\tt int wtouchln(win, y, n, changed)} \label{fun_wtouchln}\\
  {\tt int untouchwin(win)} \label{fun_untouchwin}\\
  Le indica a ncurses que toda la ventana \vdmarg{win} o las l\'{\i}neas
  que van desde la \vdmarg{start} hasta la \vdmarg{start+count} se han
  tocado.  Por ejemplo, cuando tiene algunas ventanas que se solapan
  (como en el ejemplo de \vdmunix{type.c}) y se produce un cambio en
  una ventana, no se afecta a la imagen de la otra.
  
  \vdmfunc{wtouchln(\ldots)} marcar\'a como tocadas las \vdmarg{n}
  l\'{\i}neas que comienzan en \vdmarg{y}.  Si \vdmarg{change} se pone en
  TRUE, entonces se marcan como tocadas dichas l\'{\i}neas, sino se marcan
  como que no han sido tocadas (cambiadas o no cambiadas).
  
  \vdmfunc{untouchwin(win)} marcar\'a la ventana \vdmarg{win} como que
  no ha sido modificada desde la \'ultima llamada a \vdmfunc{refresh()}.
  
\item {\tt int is\_linetouched(win, line)} \label{fun_is_linetouched}\\
  {\tt int is\_wintouched(win)} \label{fun_is_wintouched}\\
  Con estas funciones, Ud.\@ puede controlar si la l\'{\i}nea \vdmarg{line}
  o la ventana \vdmarg{win} ha sido tocada desde la \'ultima llamada a
  \vdmfunc{refresh()}.
\end{itemize}




\section{Atributos de v\'{\i}deo y colores}

Los atributos son capacidades especiales de la terminal que se
utilizan al escribir los car\'acteres en la pantalla.  Los car\'acteres
pueden escribirse en negrilla (\emph{bold}), subrayado, parpadeantes,
etc.\@.  Con ncurses, Ud.\@ disfruta de la posibilidad de encender y
apagar estos atributos y de esa manera puede mejorar la apariencia de
la salida.  Los posibles atributos se enumeran en la siguiente tabla:

\begin{table}
  \caption{Ncurses - atributos}\label{tab_attr}
  \begin{center}
    \begin{tabular}{l|l}
      {\bf Definici\'on} & {\bf Atributo} \\ \hline
      A\_ATTRIBUTES    &  m\'ascara para los atributos (chtype) \\
      A\_NORMAL        &  normal, quita todos los otros \\
      A\_STANDOUT      &  el mejor modo para resaltar \\
      A\_UNDERLINE     &  subrayado \\
      A\_REVERSE       &  v\'{\i}deo en reverso \\
      A\_BLINK         &  parpadeante \\
      A\_DIM           &  brillo disminu\'{\i}do o medio brillo \\
      A\_BOLD          &  negrilla o brillo extra \\
      A\_ALTCHARSET    &  usar conjunto de car\'acteres alternativos \\
      A\_INVIS         &  invisible \\
      A\_PROTECT       &  ??? \\
      A\_CHARTEXT      &  m\'ascara para el car\'acter actual (chtype) \\
      A\_COLOR         &  m\'ascara para el color \\
      COLOR\_PAIR(n)   &  que el par de colores sea el almacenado en n\\
      PAIR\_NUMBER(a)  &  obtener el par de colores almacenado en el
                          atributo a  \\
    \end{tabular}
  \end{center}
 \end{table}

Ncurses define ocho colores que Ud.\@ puede utilizar en una terminal
que puede mostrar colores.  Primero, inicialice las estructuras de
datos para color con \vdmfunc{start\_color()}, luego controle la
existencia de las capacidades de color con \vdmfunc{has\_colors()}.
\vdmfunc{start\_color()} inicializar\'a {\it COLORS}, la m\'axima cantidad
de colores que puede manejar la terminal, y {\it COLOR\_PAIR}, la
m\'axima cantidad de pares de colores que podr\'a definir.

\begin{table} 
  \caption{Ncurses - colores} \label{tab_color}
  \begin{center}
    \begin{tabular}{l|l}
    {\bf Definici\'on} &  {\bf Color} \\ \hline
    COLOR\_BLACK   &  negro \\
    COLOR\_RED     &  rojo \\
    COLOR\_GREEN   &  verde \\
    COLOR\_YELLOW  &  amarillo \\
    COLOR\_BLUE    &  azul \\
    COLOR\_MAGENTA &  magenta \\
    COLOR\_CYAN    &  cyan \\
    COLOR\_WHITE   &  blanco \\
    \end{tabular}
  \end{center}
\end{table}

Los atributos se pueden combinar con el operador OR "<'${\verbar}$">,
as\'{\i} que puede obtener negrilla y parpadeante mediante:

\begin{tscreen}
\begin{verbatim}
    A_BOLD|A_BLINK
\end{verbatim}
\end{tscreen}

Cuando se asignan ciertos atributos \vdmarg{attr} a una ventana, todos
los car\'acteres que escriba en dicha vantana se mostrar\'an con esas
propiedades, hasta haga un cambio en los atributos de la ventana.  No
se perder\'an cuando enrolle (\texttt{scroll}) la ventana, ni cuando la
mueva, o accione sobre ella de cualquier otra manera.

Si Ud.\@ escribe programas que pueden utilizar ncurses y BSD curses,
recuerde que la BSD curses no permite el uso de colores.  (Tampoco hay
colores en las versiones antiguas de ncurses tipo SYS~V.)  As\'{\i} que si
desea utilizar ambas bibliotecas, deber\'a utilizar estructuras de
compilaci\'on condicional con \vdmunix{\#ifdef}.

\begin{itemize}
\item {\tt int attroff(attr)} \label{fun_attroff}\\
  {\tt int wattroff(win, attr)} \label{fun_wattroff}\\
  {\tt int attron(attr)} \label{fun_attron}\\
  {\tt int wattron(win, attr)} \label{fun_wattron}\\
  Encienden (on) o apagan (off) el atributo especificado mediante
  \vdmarg{attr} sin tocar los otros atributos en la ventana (que ser\'a
  \vdmscr{stdscr} o \vdmarg{win}).
  
\item {\tt int attrset(attr)} \label{fun_attrset}\\
  {\tt int wattrset(win, attr)} \label{fun_wattrset}\\
  Hace que los atributos de \vdmscr{stdscr} o \vdmarg{win} se
  configuren en \vdmarg{attr}.
  
\item {\tt int standout()} \label{fun_standout}\\
  {\tt int standend()} \label{fun_standend}\\
  {\tt int wstandout(win)} \label{fun_wstandout}\\
  {\tt int wstandend(win)} \label{fun_wstandend}\\
  Enciende y apaga el modo \texttt{standout} sobre la ventana
  (\vdmscr{stdscr} o \vdmarg{win}), que se utiliza para resaltar
  texto.
  
\item {\tt chtype getattrs(win)} \label{fun_getattrs}\\
  Retorna los atributos que tiene \vdmarg{win} al momento de la
  llamada a esta funci\'on.
  
\item {\tt bool has\_colors()} \label{fun_has_colors}\\
  Retorna TRUE si la terminal tiene colores. Antes de utilizar
  colores, Ud.\@ debe controlar con \vdmfunc{has\_colors()} que la
  terminal los pueda manejar, y a continuaci\'on debe inicializar los
  colores con \vdmfunc{start\_color())}.
  
\item {\tt bool can\_change\_color()} \label{fun_can_change_color}\\
  TRUE si la terminal puede redefinir colores.
  
\item {\tt int start\_color()} \label{fun_start_color}\\
  Inicializaci\'on de colores.  Debe llamar a esta funci\'on antes de
  utilizar el manejo de colores!
  
\item {\tt int init\_pair(pair, fg, bg)} \label{fun_init_pair}\\
  Cuando en los argumentos a funciones de ncurses, donde se espera un
  atributo queremos poner colores, debemos utilizar los \textbf{pares
    de colores}.  La definici\'on de un par de colores se realiza con
  \vdmfunc{init\_pair(\ldots)}.  \vdmarg{fg} es el color del primer
  plano (car\'acteres) y
  \vdmarg{bg} es el color del fondo que se asocian en el par de
  colores \vdmarg{pair}.  El par de colores \vdmarg{pair} no es m\'as
  que un n\'umero en el rango de
 1 a $COLOR\hspace{.167em}PAIRS-1$ (Si, ley\'o bien, desde el~1; pues el~0
  est\'a reservado para el par negro sobre blanco.  Una vez que ha sido
  definido, el \vdmarg{pair} se comporta como un atributo.  Por
  ejemplo, si desea poner car\'acteres rojos sobre fondo azul, haga:

\begin{tscreen}
\begin{verbatim}
    init_pair(1,COLOR_RED,COLOR_BLUE);
\end{verbatim}
\end{tscreen}

Ahora puede llamar a \vdmfunc{wattr(\ldots)} para que  \vdmarg{win}
tenga como colores los de nustro nuevo par:

\begin{tscreen}
\begin{verbatim}
    wattr(win,COLOR_PAIR(1));
\end{verbatim}
\end{tscreen}

O puede combinar pares de colores con otros atributos, como se muestra
a continuaci\'on:

\begin{tscreen}
\begin{verbatim}
    wattr(win ,A_BOLD|COLOR_PAIR(1));
    wattr(win1,A_STANDOUT|COLOR_PAIR(1));
\end{verbatim}
\end{tscreen}

El primero pone los colores que hab\'{\i}amos seleccionado y adem\'as
enciende el atributo \texttt{BOLD}; el segundo ejemplo pone los
colores y adem\'as levanta el brillo (\texttt{STANDOUT}), as\'{\i} que
obtenemos rojo brillante sobre azul.

\item {\tt int pair\_content(pair, f, b)} \label{fun_pair_content}\\
  Obtiene los colores de primer plano (\texttt{f}) y fondo
  (\texttt{b}) correspondientes al par de colores \vdmarg{pair}.
  
\item {\tt int init\_color(color, r, g, b)} \label{fun_init_color}\\
  Cambia los componentes del color \vdmarg{color}.  Los componentes
  son \vdmarg{r} (rojo), \vdmarg{g} (verde) and \vdmarg{b} (azul), y
  pueden tomar valores en el rango 1 a $COLORS-1$.
  
\item {\tt int color\_content(color, r, g, b)} \label{fun_color_content}\\
  Devuelve los componentes \vdmarg{r} (rojo), \vdmarg{g} (verde) y
  \vdmarg{b} (azul) que forman un dado \vdmarg{color}.
\end{itemize}

Bueno, la pregunta ahora ser\'a: c\'omo combinar atributos y colores?.
Algunas terminales, como la consola de Linux, tienen colores; otras,
como xterm, vt100, no los tienen.  El c\'odigo que se muestra a
continuaci\'on deber\'{\i}a resolver este problema:

\begin{tscreen}
\begin{verbatim}
void CheckColor(WINDOW *win1, WINDOW *win2)
{
 start_color();
 if (has_colors()){
   /* muy bien, tenemos colores, as\'{\i} que definimos los pares de
    * colores para car\'acter y para fondo.
    */
   init_pair(1,COLOR_BLUE,COLOR_WHITE);
   init_pair(2,COLOR_WHITE,COLOR_RED);
   /* ahora usamos los pares de colores reci\'en definidos para
    * configurar las ventanas
    */
   wattrset(win1,COLOR_PAIR(2));
   wattrset(win2,COLOR_PAIR(1));
 }
 else{
   /* Arf!, no hay colores (a lo mejor estamos en una vt100 o xterm).
    * Bien, entonces utilizaremos negro sobre blanco
    */
   wattrset(win1,A_REVERSE);
   wattrset(win2,A_BOLD);
 }
return;
}
\end{verbatim}
\end{tscreen}

Primero, la funci\'on {\it CheckColor} inicializa los colores con
\vdmfunc{start\_color()}, luego la funci\'on \vdmfunc{has\_colors()}
retornar\'a TRUE si la terminal puede mostrar colores.  Si nos
encontramos que acepta colores, llamamos a
\vdmfunc{init\_pair(\ldots)} para combinar los colores de frente con
fondo en un par de colores, y luego llamamos a 

\vdmfunc{wattrset(\ldots)} para configurar las ventanas con los
colores correspondientes.  En el caso en que no tuvi\'eramos la
posibilidad de colores en nuestra terminal, nos alcanza con utilizar
 \vdmfunc{wattrset(\ldots)} para poner los atributos que tolera
 nuestra terminal monocroma.
 
Para obtener colores en xterm, la mejor manera que he encontrado
consiste en utilizar la ansi\_xterm con las entradas emparchadas
correspondientes al terminfo del Midnight Commander.  Si Ud.\@ quiere
usar la misma soluci\'on, consiga los fuentes de ansi\_xterm y Midnight
Commander (mc-x.x.tar.gz); compile la ansi\_xterm; use tic con
xterm.ti y vt100.ti que obtiene del archivo mc-x.x.tar.gz; ejecute
ansi\_xterm y compruebe su funcionamiento.


\section{Coordenadas del cursor y de las ventanas}

\begin{itemize}
\item {\tt int move(y, x)} \label{fun_move}\\
  {\tt int wmove(win, y, x)} \label{fun_wmove}\\
  \vdmfunc{move()} mueve el cursor dentro de \vdmscr{stdscr},
  \vdmfunc{wmove(win)} mueve el cursor dentro de la ventana
  \vdmarg{win}. Para las funciones de entrada/salida, se definen
  macros adicionales que mueven el cursor antes de llamar a la funci\'on
  especificada.
  
\item {\tt int curs\_set(bf)} \label{fun_curs_set}\\
  Muestra u oculta el cursor, si la terminal es capaz de esta
  operaci\'on. 
  
\item {\tt void getyx(win, y, x)} \label{fun_getyx}\\
  \vdmfunc{getyx(\ldots)} devuelve la posici\'on del cursor al momento
  de la llamada.  \notenm{Es una macro}
  
\item {\tt void getparyx(win, y, x)} \label{fun_getparyx}\\
  Cuando \vdmarg{win} es una subventana, \vdmfunc{getparyx(\ldots)}
  nos entregar\'a las coordenadas de la ventana en relaci\'on a su ventana
  paterna, almacen\'andolas en \vdmarg{y} y \vdmarg{x}.  En cualquier
  otro caso \vdmarg{y} y \vdmarg{x} se pondr\'an a -1.  \noteni
  

\item {\tt void getbegyx(win, y, x)} \label{fun_getbegyx}\\
  {\tt void getmaxyx(win, y, x)} \label{fun_getmaxyx}\\
  {\tt int getmaxx(win)} \label{fun_getmaxx}\\
  {\tt int getmaxy(win)} \label{fun_getmaxy}\\
  Guardan en \vdmarg{y} y \vdmarg{x} las coordenadas de posici\'on y
  tama\~no de \vdmarg{win}.

\item {\tt int getsyx(int y, int x)} \label{fun_getsyx}\\
  {\tt int setsyx(int y, int x)} \label{fun_setsyx}\\
  Almacena la posici\'on del cursor dentro de la pantalla virtual en
  \vdmarg{y} y \vdmarg{x} o lo posiciona all\'{\i}, respectivamente.
  Si pone a -1 los valores de \vdmarg{y} y \vdmarg{x} y llama a
  \vdmfunc{getsyx(\ldots)}, se habilitar\'a {\it leaveok}.
\end{itemize}





\section{Movi\'endonos por all\'{\i}}

\begin{itemize}
\item {\tt int scrollok(win, bf)} \label{fun_scrollok}\\
  Si se pone a TRUE, entonces el texto en la ventana \vdmarg{win} se
  mover\'a una l\'{\i}nea hacia arriba cuando se escriba un car\'acter (o un
  cambio de l\'{\i}nea) y el cursor estaba posicionado sobre el car\'acter de
  la esquina inferior derecha.  Si se pone a FALSE, el cursor quedar\'a
  en la misma posici\'on.
  
  Cuando se habilita (con TRUE), se puede mover el contenido de las
  ventanas mediante la utilizaci\'on de las siguientes funciones.
  \notenm{Las l\'{\i}neas del contenido de la ventana tambi\'en se mover\'an si
    escribe un cambio de l\'{\i}nea en la \'ultima l\'{\i}nea de la ventana.  As\'{\i}
    que tenga cuidado con \vdmfunc{scrollok(\ldots)} o le soprender\'an
    los resultados.}
  
\item {\tt int scroll(win)} \label{fun_scroll}\\
  Mueve las l\'{\i}neas de la ventana (y en la estructura de datos) una
  l\'{\i}nea hacia ariba.
  
\item {\tt int scrl(n)} \label{fun_scrl}\\
  {\tt int wscrl(win, n)} \label{fun_wscrl}\\
  Estas funciones mueven la pantalla \vdmscr{stdscr} o la ventana
  \vdmarg{win} hacia arriba o hacia abajo, de acuerdo al valor del
  entero \vdmarg{n}.  Si \vdmarg{n} es positivo, las l\'{\i}neas de la
  ventana se mueven \vdmarg{n} l\'{\i}neas hacia arriba, si \vdmarg{n} es
  negativo se mover\'a hacia abajo \vdmarg{n} l\'{\i}neas.
  

\item {\tt int setscrreg(t, b)} \label{fun_setscrreg}\\
  {\tt int wsetscrreg(win, t, b)} \label{fun_wsetscrreg}\\
  Configura una regi\'on de movimientos por software.
\end{itemize}


El c\'odigo que se muestra a continuaci\'on le mostrar\'a c\'omo puede obtener
el efecto de movimiento de las l\'{\i}neas de texto en la pantalla.  Vea
adem\'as en \vdmunix{type.c} en el directorio de los ejemplos.

Tenemos una ventana con 18~l\'{\i}neas y 66~columnas, en la cual queremos
mover el texto. {\it s$[]$} es un vector de car\'acteres con el texto.
  {\it max\_s} es el n\'umero de la \'ultima l\'{\i}nea en
{\it s$[]$}.  {\it clear\_line} escribe car\'acteres blancos desde la
posici\'on actual del cursor hasta el fin de la l\'{\i}nea, y utiliza los
atributos actuales en la ventana (y no con el atributo A\_NORMAL como
lo hace {\tt clrtoeol()}.  {\it beg} es la \'ultima l\'{\i}nea de

{\it s$[]$} que se muestra en la pantalla en cualquier momento dado.
{\it scroll} es un tipo enumerado para indicar a la funci\'on qu\'e es lo
que hay que hacer: si mostrar la l\'{\i}nea SIGuiente o la ANTerior.

\begin{tscreen}
\begin{verbatim}
enum{ANT,SIG)};

void scroll_s(WINDOW *win, int scroll)
{
 /* verificar si necesitamos mover las l\'{\i}neas, 
  * y si hay l\'{\i}neas para mover
  */
 if((scroll==SIG)&&(beg<=(max_s-18))){
 /* una l\'{\i}nea para abajo */
     beg++;
 /* habilitar el movimiento */
     scrollok(win, TRUE);
 /* mover */
     wscrl(win, +1);
 /* deshabilitar el movimiento */
     scrollok(win, FALSE);
 /* colocar la cadena de car\'acteres de la \'ultima l\'{\i}nea */
     mvwaddnstr(win,17,0,s[beg+17],66);
 /* limpiar la \'ultima l\'{\i}nea despu\'es del \'ultimo car\'acter ocupado
  * y hasta el fin de l\'{\i}nea.
  * Si no se hace, los atributos se ver\'an mal 
  */
     clear_line(66,win);
 }
 else if((scroll==ANT)&&(beg>0)){
     beg--;
     scrollok(win, TRUE);
     wscrl(win, -1);
     scrollok(win, FALSE);
     mvwaddnstr(win,0,0,s[beg],66);
     clear_line(66,win);
 }
 wrefresh(win);
return;
}

\end{verbatim}
\end{tscreen}




\section{Pads}

\begin{itemize}
  \item {\tt WINDOW *newpad(nlines, ncols)} \label{fun_newpad}\\
  \item {\tt WINDOW *subpad(orig, nlines, ncols,  begy, begx)} \label{fun_subpad}\\
  \item {\tt int prefresh(pad, pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol)} \label{fun_prefresh}\\
  \item {\tt int pnoutrefresh(pad, pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol)} \label{fun_pnoutrefresh}\\
  \item {\tt int pechochar(pad, ch)} \label{fun_pechochar}\\
\end{itemize}




\section{Soft-labels}

\begin{itemize}
\item {\tt int slk\_init(int fmt)} \label{fun_slk_init}\\
\item {\tt int slk\_set(int labnum, char *label, int fmt)}
\label{fun_slk_set}\\
\item {\tt int slk\_refresh()} \label{fun_slk_refresh}\\
\item {\tt int slk\_noutrefresh()} \label{fun_slk_noutrefresh}\\
\item {\tt char *slk\_label(int labnum)} \label{fun_slk_label}\\
\item {\tt int slk\_clear()} \label{fun_slk_clear}\\
\item {\tt int slk\_restore()} \label{fun_slk_restore}\\
\item {\tt int slk\_touch()} \label{fun_slk_touch}\\
  

\item {\tt int slk\_attron(chtype attr)} \label{fun_slk_attron}\\
  {\tt int slk\_attrset(chtype attr)} \label{fun_slk_attrset}\\
  {\tt int slk\_attroff(chtype attr)} \label{fun_slk_attroff}\\
  Estas funciones corresponden a \vdmfunc{attron(attr)},
  \vdmfunc{attrset(attr)} y \vdmfunc{attroff(attr)}.  No se han
  constru\'{\i}do a\'un.
\end{itemize}

%% CBALLARD-1-END

%% LUISGH-1-START
\section{Miscel\'anea}

\begin{itemize}
  \item {\tt int beep()} \label{fun_beep}\\
  \item {\tt int flash()} \label{fun_flash}\\
  \item {\tt char *unctrl(chtype c)} \label{fun_unctrl}\\
  \item {\tt char *keyname(int c)} \label{fun_keyname}\\
  \item {\tt int filter()} \label{fun_filter}\\
        \noteni
  \item {\tt void use\_env(bf)} \label{fun_use_env}\\
  \item {\tt int putwin(WINDOW *win, FILE *filep)} \label{fun_putwin}\\
        \noteni
  \item {\tt WINDOW *getwin(FILE *filep)} \label{fun_getwin}\\
        \noteni
  \item {\tt int delay\_output(int ms)} \label{fun_delay_output}\\
  \item {\tt int flushinp()} \label{fun_flushinp}\\
\end{itemize}




\section{Acceso de Bajo Niv\'el}

\begin{itemize}
  \item {\tt int def\_prog\_mode()} \label{fun_def_prog_mode}\\    % == saveterm()
  \item {\tt int def\_shell\_mode()} \label{fun_def_shell_mode}\\
  \item {\tt int reset\_prog\_mode()} \label{fun_reset_prog_mode}\\  % == fixterm()
  \item {\tt int reset\_shell\_mode()} \label{fun_reset_shell_mode}\\ % == resetterm()
  \item {\tt int resetty()} \label{fun_resetty}\\
  \item {\tt int savetty()} \label{fun_savetty}\\
  \item {\tt int ripoffline(int line, int (*init)(WINDOW *, int))} \label{fun_ripoffline}\\
  \item {\tt int napms(int ms)} \label{fun_napms}\\
\end{itemize}




\section{Volcado de Pantalla}

\begin{itemize}
  \item {\tt int scr\_dump(char *filename)} \label{fun_scr_dump}\\
        \noteni
  \item {\tt int scr\_restore(char *filename)} \label{fun_scr_restore}\\
        \noteni
  \item {\tt int scr\_init(char *filename)} \label{fun_scr_init}\\
        \noteni
  \item {\tt int scr\_set(char *filename)} \label{fun_scr_set}\\
        \noteni
\end{itemize}




\section{Emulaci\'on Termcap}

\begin{itemize}
  \item {\tt int tgetent(char *bp, char *name)} \label{fun_nc_tgetent}\\
  \item {\tt int tgetflag(char id[2])} \label{fun_nc_tgetflag}\\
  \item {\tt int tgetnum(char id[2])} \label{fun_nc_tgetnum}\\
  \item {\tt char *tgetstr(char id[2], char **area)} \label{fun_nc_tgetstr}\\
  \item {\tt char *tgoto(char *cap, int col, int row)} \label{fun_tgoto}\\
  \item {\tt int tputs(char *str, int affcnt, int (*putc)())} \label{fun_nc_tputs}\\
\end{itemize}




\section{Funciones Terminfo}

\begin{itemize}
  \item {\tt int setupterm(char *term, int fildes, int *errret)} \label{fun_setupterm}\\
  \item {\tt int setterm(char *term)} \label{fun_setterm}\\
  \item {\tt int set\_curterm(TERMINAL *nterm)} \label{fun_set_curterm}\\
  \item {\tt int del\_curterm(TERMINAL *oterm)} \label{fun_del_curterm}\\
  \item {\tt int restartterm(char *term, int fildes, int *errret)} \label{fun_restartterm}\\
        \noteni
        
  \item {\tt char *tparm(char *str, p1, p2, p3, p4, p5, p6, p7, p8, p9)} \label{fun_tparm}\\
        p1 - p9 long int.
  \item {\tt int tputs(char *str, int affcnt, int (*putc)(char))} \label{fun_tputs}\\
  \item {\tt int putp(char *str)} \label{fun_putp}\\
  \item {\tt int vidputs(chtype attr, int (*putc)(char))} \label{fun_vidputs}\\
  \item {\tt int vidattr(chtype attr)} \label{fun_vidattr}\\
  \item {\tt int mvcur(int oldrow, int oldcol, int newrow, int newcol)} \label{fun_mvcur}\\
  \item {\tt int tigetflag(char *capname)} \label{fun_tigetflag}\\
  \item {\tt int tigetnum(char *capname)} \label{fun_tigetnum}\\
  \item {\tt int tigetstr(char *capname)} \label{fun_tigetstr}\\
\end{itemize}




\section{Funciones de Depurado}

\begin{itemize}
  \item {\tt void \_init\_trace()} \label{fun__init_trace}\\
  \item {\tt void \_tracef(char *, ...)} \label{fun__tracef}\\
  \item {\tt char *\_traceattr(mode)} \label{fun__traceattr}\\
  \item {\tt void traceon()} \label{fun_traceon}\\
  \item {\tt void traceoff()} \label{fun_traceoff}\\
\end{itemize}




\section{Atributos Terminfo}

\subsection{Atributos L\'ogicos}
\begin{small}
\begin{tabbing}
1234567890123456789012\=3456123\=45678\=901234567890\kill
{\bf Variable} \> {\bf Nombre} \> {\bf C\a'od.}  \> {\bf Descripci\a'on}\\
               \> {\bf Car.} \> {\bf Int.}  \>                  \\
auto\_left\_margin         \> {\tt bw}      \> {\tt bw} \>     cub1 ajusta de la columna 0 a la \a'ultima\\
auto\_right\_margin        \> {\tt am}      \> {\tt am} \>     La terminal tiene m\a'argenes autom\a'aticos\\
back\_color\_erase         \> {\tt bce}     \> {\tt ut} \>     Borrado de pantalla con el color del segundo plano\\
can\_change                \> {\tt ccc}     \> {\tt cc} \>     La terminal puede redefinir los colores existentes\\
ceol\_standout\_glitch     \> {\tt xhp}     \> {\tt xs} \>     Los caracteres destacados no se borran al sobresecibirse (hp)\\
col\_addr\_glitch          \> {\tt xhpa}    \> {\tt YA} \>     S\a'olo se permite movimientos positivos para hpa/mhpa\\
cpi\_changes\_res          \> {\tt cpix}    \> {\tt YF} \>     El cambio de la frecuencia de puntos de un caracter cambia la resoluci\a'on\\
cr\_cancels\_micro\_mode   \> {\tt crxm}    \> {\tt YB} \>     El uso del retorno de carro (cr) sale del modo micro\\
eat\_newline\_glitch       \> {\tt xenl}    \> {\tt xn} \>     El caracter de nueva l\a'{\i}nea (nl) se ignora pasadas las 80 cols (Concepto)\\
erase\_overstrike          \> {\tt eo}      \> {\tt eo} \>     Se pueden borrar los sobreimpresionados con un blanco\\
generic\_type              \> {\tt gn}      \> {\tt gn} \>     Tipo de l\a'{\i}nea gener\a'erico (p.ej., llamada, conmutador).\\
hard\_copy                 \> {\tt hc}      \> {\tt hc} \>     La terminal que produce copia sobre papel\\
hard\_cursor               \> {\tt chts}    \> {\tt HC} \>     El cursor es dif\a'{\i}cil de ver\\
has\_meta\_key             \> {\tt km}      \> {\tt km} \>     Tiene la tecla meta (shift activa el bit de paridad)\\
has\_print\_wheel          \> {\tt daisy}   \> {\tt YC} \>     La impresora necesita un operador para cambiar de conjunto de caracteres\\
has\_status\_line          \> {\tt hs}      \> {\tt hs} \>     Tiene "l\a'{\i}nea de estado" extra\\
hue\_lightness\_saturation \> {\tt hls}     \> {\tt hl} \>     La terminal utiliza \a'unicamente la notaci\a'on HLS para color\\
                           \>               \>          \>     (Tektronix)\\
insert\_null\_glitch       \> {\tt in}      \> {\tt in} \>     El modo de inserci\a'on distingue los caracteres nulos\\
lpi\_changes\_res          \> {\tt lpix}    \> {\tt YG} \>     El cambio del la frecuencia de puntos de la l\a'{\i}nea cambia la resoluci\a'on\\
memory\_above              \> {\tt da}      \> {\tt da} \>     Puede almacenar informaci\a'on encima de la pantalla\\
memory\_below              \> {\tt db}      \> {\tt db} \>     Puede almacenar informaci\a'on debajo de la pantalla\\
move\_insert\_mode         \> {\tt mir}     \> {\tt mi} \>     No es arriesgado moverse durante la inserci\a'on\\
move\_standout\_mode       \> {\tt msgr}    \> {\tt ms} \>     No es arriesgado moverse en los modo destacados\\
needs\_xon\_xoff           \> {\tt nxon}    \> {\tt nx} \>     No vale rellenar, se requiere xon/xoff\\
no\_esc\_ctl\_c            \> {\tt xsb}     \> {\tt xb} \>     Colmena (f1=escape, f2=ctrl C)\\
non\_rev\_rmcup            \> {\tt nrrmc}   \> {\tt NR} \>     smcup no deshace rmcup\\
no\_pad\_char              \> {\tt npc}     \> {\tt NP} \>     No existe caracter de relleno\\
non\_dest\_scroll\_region  \> {\tt ndscr}   \> {\tt ND} \>     La regi\a'on de paginado no destruye la informaci\a'on\\
over\_strike               \> {\tt os}      \> {\tt os} \>     La terminal sobreescribe\\
prtr\_silent               \> {\tt mc5i}    \> {\tt 5i} \>     La impresora no env\a'{\i}a eco a la pantalla\\
row\_addr\_glitch          \> {\tt xvpa}    \> {\tt YD} \>     S\a'olo se permite movimientos positivos para vhp/mvpa\\
semi\_auto\_right\_margin  \> {\tt sam}     \> {\tt YE} \>     La escritura en la \a'ultima columna resulta en un returno de carro\\
status\_line\_esc\_ok      \> {\tt eslok}   \> {\tt es} \>     Se puede usar el caracter de escape en la l\a'{\i}nea de estado\\
dest\_tabs\_magic\_smso    \> {\tt xt}      \> {\tt xt} \>     Los tabuladores arrunian, magic so char (Teleray 1061)\\
tilde\_glitch              \> {\tt hz}      \> {\tt hz} \> Hazel-tine; no se puede imprimir el s\a'imbolo de tilde\\
transparent\_underline     \> {\tt ul}      \> {\tt ul} \>     El caracter de subrayado se sobreescribe\\
xon\_xoff                  \> {\tt xon}     \> {\tt xo} \>     La terminal usa el protocolo xon/xoff\\
\end{tabbing}
\end{small}

\subsection{N\'umeros}
\begin{small}
\begin{tabbing}
12345678901234567890\=12345612\=45678\=901234567890\kill
{\bf Variable} \> {\bf Nombre} \> {\bf C\a'od.}  \> {\bf Descripci\a'on}\\
               \> {\bf Car.} \> {\bf Int.}  \>                  \\
bit\_image\_entwining      \> {\tt bitwin}  \> {\tt Yo} \>    No est\a'a documentado en el SYSV\\
buffer\_capacity           \> {\tt bufsz}   \> {\tt Ya} \>    N\a'umero de bytes almacenados antes de imprimir\\
columns                    \> {\tt cols}    \> {\tt co} \>    N\a'umero de columnas por l\a'{\i}nea\\
dot\_vert\_spacing         \> {\tt spinv}   \> {\tt Yb} \>    Espaciado horizonal de los puntos en puntos por pulgada\\
dot\_horz\_spacing         \> {\tt spinh}   \> {\tt Yc} \>    Espaciado vertical de pines en pines por pulgada\\
init\_tabs                 \> {\tt it}      \> {\tt it} \>    Tabuladores iniclamente cada \# de espacios\\
label\_height              \> {\tt lh}      \> {\tt lh} \>    Filas por etiqueta\\
label\_width               \> {\tt lw}      \> {\tt lw} \>    Columnas por etiqueta\\
lines                      \> {\tt lines}   \> {\tt li} \>    N\a'umero de l\a'{\i}neas por pantalla o p\a'agina\\
lines\_of\_memory          \> {\tt lm}      \> {\tt lm} \>    N\a'umero de l\a'{\i}neas en la memoria. 0 indica que var\a'{\i}a.\\
magic\_cookie\_glitch      \> {\tt xmc}     \> {\tt sg} \>    N\a'umero de espacios que producen smso o rmso\\
max\_colors                \> {\tt colors}  \> {\tt Co} \>    M\a'aximo n\a'umero de colores en la pantalla\\
max\_micro\_address        \> {\tt maddr}   \> {\tt Yd} \>    Valor m\a'aximo de las micro\_... direcciones\\
max\_micro\_jump           \> {\tt mjump}   \> {\tt Ye} \>    Valor m\a'aximo de parm\_...\_micro\\
max\_pairs                 \> {\tt pairs}   \> {\tt pa} \>    N\a'umero m\a'aximo de parejas de color en la pantalla\\
micro\_col\_size           \> {\tt mcs}     \> {\tt Yf} \>    Tama~no del paso de caracter en modo micro\\
micro\_line\_size          \> {\tt mls}     \> {\tt Yg} \>    Tama~no del paso de l\a'{\i}nea en modo micro\\
no\_color\_video           \> {\tt ncv}     \> {\tt NC} \>    Atributos de v\a'{\i}deo que no se pueden usar en colores\\
number\_of\_pins           \> {\tt npins}   \> {\tt Yh} \>    N\a'umero de pines en la cabeza de impresi\a'on\\
num\_labels                \> {\tt nlab}    \> {\tt Nl} \>    N\a'umero de etiquetas en la pantalla\\
output\_res\_char          \> {\tt orc}     \> {\tt Yi} \>    Resoluci\a'on horizontal en unidades por l\a'{\i}nea\\
output\_res\_line          \> {\tt orl}     \> {\tt Yj} \>    Resoluci\a'on vertical en unidades por l\a'{\i}nea\\
output\_res\_horz\_inch    \> {\tt orhi}    \> {\tt Yk} \>    Resoluci\a'on horizontal en unidades por pulgada\\
output\_res\_vert\_inch    \> {\tt orvi}    \> {\tt Yl} \>    Resoluci\a'on vertical en unidades por pulgada\\
padding\_baud\_rate        \> {\tt pb}      \> {\tt pb} \>    M\a'{\i}nimo numero de baudios que necesita relleno de cr/nl\\
virtual\_terminal          \> {\tt vt}      \> {\tt vt} \>    N\a'umero de terminal virtual (Sistema UNIX)\\
width\_status\_line        \> {\tt wsl}     \> {\tt ws} \>    N\a'umero de columnas en la l\a'{\i}nea de estado\\
\end{tabbing}
(Los siguientes atributos numericos est\'an presentes en la estructura
term del SYSV, pero no se han documentado aun en la p\'agina de manual.
Los comentarios provienen del fichero de cabecera que contiene la
definici\'on de la estructura.)
\begin{tabbing}
12345678901234567890\=12345612\=45678\=901234567890\kill
bit\_image\_type           \> {\tt bitype}  \> {\tt Yp} \>  Tipo de dispositivo de im\a'agenes por bit\\
buttons                    \> {\tt btns}    \> {\tt BT} \>  N\a'umero de botones por rat\a'on\\
max\_attributes            \> {\tt ma}      \> {\tt ma} \>  N\a'umero m\a'aximo de atributos que la terminal puede manejar\\
maximum\_windows           \> {\tt wnum}    \> {\tt MW} \>  N\a'umero m\a'aximo de vetanas definibles\\
print\_rate                \> {\tt cps}     \> {\tt Ym} \>  Velocidad de impresi\a'on en caracteres por segundo\\
wide\_char\_size           \> {\tt widcs}   \> {\tt Yn} \>  Tama~no del paso de un caracter en modo doble ancho\\
\>\>\>\\
\>\>\>\\
\end{tabbing}
\end{small}



\subsection{Cadenas}
\begin{small}
\begin{tabbing}
12345678901234567890123\=456123456\=78901\=4567890\kill
{\bf Variable} \> {\bf Nombre} \> {\bf C\a'od.}  \> {\bf Descripci\a'on}\\
               \> {\bf Car.} \> {\bf Int.}  \>                  \\
acs\_chars                  \> {\tt acsc}      \> {\tt ac} \>   Parejas de conjuntos de caracteres gr\a'aficos - por defecto vt100\\
alt\_scancode\_esc          \> {\tt scesa}     \> {\tt S8} \>   Escape alternativo para emulaci\a'on del c\a'odigo escaneado\\
                            \>                 \>          \>   (por defecto setoma vt100)\\
back\_tab                   \> {\tt cbt}       \> {\tt bt} \>   Tabulador inverso (P)\\
bell                        \> {\tt bel}       \> {\tt bl} \>   Se~nal audible (timbre) (P)\\
bit\_image\_repeat          \> {\tt birep}     \> {\tt Xy} \>   Repetir la c\a'elula de imagen por bits \#1, \#2 veces\\
                            \>                 \>          \>   (usar tparm)\\
bit\_image\_newline         \> {\tt binel}     \> {\tt Zz} \>   Desplazarse hasta la siguiente fila de la imagen por bits\\
                            \>                 \>          \>   (usar tparm)\\
bit\_image\_carriage\_return\> {\tt bicr}      \> {\tt Yv} \>   Desplazarse hasta el comienzo de esta fila\\
                            \>                 \>          \>   (usar tparm)\\
carriage\_return            \> {\tt cr}        \> {\tt cr} \>   Retorno de carro (P*)\\
change\_char\_pitch         \> {\tt cpi}       \> {\tt ZA} \>   Cambia \# de caracteres por pulgada\\
change\_line\_pitch         \> {\tt lpi}       \> {\tt ZB} \>   Cambia \# de l\a'{\i}neas por pulgada\\
change\_res\_horz           \> {\tt chr}       \> {\tt ZC} \>   Cambia la resoluci\a'on horizontal\\
change\_res\_vert           \> {\tt cvr}       \> {\tt ZD} \>   Cambia la resoluci\a'on vertical\\
change\_scroll\_region      \> {\tt csr}       \> {\tt cs} \>   Cambia de las l\a'{\i}neas \#1 a la \#2\\
                            \>                 \>          \>   (vt100) (PG)\\
char\_padding               \> {\tt rmp}       \> {\tt rP} \>   Como ip pero cuando se est\a'a en modo inserci\a'on\\
char\_set\_names            \> {\tt csnm}      \> {\tt Zy} \>   Lista de los nombres de conjuntos de caracteres\\
clear\_all\_tabs            \> {\tt tbc}       \> {\tt ct} \>   Borra todos las paradas del tabulador (P)\\
clear\_margins              \> {\tt mgc}       \> {\tt MC} \>   Borra todos los m\a'argenes (superior, inferior y laterales)\\
clear\_screen               \> {\tt clear}     \> {\tt cl} \>   Borra la pantalla y desplaza el cursor al comienzo (P*)\\
clr\_bol                    \> {\tt el1}       \> {\tt cb} \>   Borra hasta el comienzo de la l\a'{\i}nea\\
clr\_eol                    \> {\tt el}        \> {\tt ce} \>   Borra hasta el final de la l\a'{\i}nea (P)\\
clr\_eos                    \> {\tt ed}        \> {\tt cd} \>   Borra hasta el final de la pantalla (P*)\\
code\_set\_init             \> {\tt csin}      \> {\tt ci} \>   Secuencia de inicio para conjuntos de c\a'odigos m\a'ultiples \\
color\_names                \> {\tt colornm}   \> {\tt Yw} \>   Da un nombre al color \#1\\
column\_address             \> {\tt hpa}       \> {\tt ch} \>   Fija la columna del cursor (PG)\\
command\_character          \> {\tt cmdch}     \> {\tt CC} \>   Caracter de cmd se puede fijar por la terminal en el prototipo\\
cursor\_address             \> {\tt cup}       \> {\tt cm} \>   Desplazamiento relativo del cursor fila \#1 columna \#2\\
                            \>                 \>          \>   (PG)\\
cursor\_down                \> {\tt cud1}      \> {\tt do} \>   Baja una l\a'{\i}nea\\
cursor\_home                \> {\tt home}      \> {\tt ho} \>   Desplaza el cursor al inicio (sin cup)\\
cursor\_invisible           \> {\tt civis}     \> {\tt vi} \>   Hace el cursor invisible\\
cursor\_left                \> {\tt cub1}      \> {\tt le} \>   Mueve el cursor un caracter hacia la izquierda\\
cursor\_mem\_address        \> {\tt mrcup}     \> {\tt CM} \>   Direccionamiento relativo del cursor a trav\a'es de memoria\\
cursor\_normal              \> {\tt cnorm}     \> {\tt ve} \>   Vuelve el cursor a modo normal (deshace vs/vi)\\
cursor\_right               \> {\tt cuf1}      \> {\tt nd} \>   Espacio no destructivo (cursor a la derecha)\\
cursor\_to\_ll              \> {\tt ll}        \> {\tt ll} \>   \a'Ultima l\a'{\i}nea, primera columna (sin cup)\\
cursor\_up                  \> {\tt cuu1}      \> {\tt up} \>   Subir l\a'{\i}nea (cursor hacia arriba)\\
cursor\_visible             \> {\tt cvvis}     \> {\tt vs} \>   Hacer el cursor muy visible\\
define\_bit\_image\_region  \> {\tt defbi}     \> {\tt Yx} \>   Definir regi\a'on de imagen de bits rectangular \\
                            \>                 \>          \>   (usar tparm)\\
define\_char                \> {\tt defc}      \> {\tt ZE} \>   Definir caracter en conjunto de caracteres\\
delete\_character           \> {\tt dch1}      \> {\tt dc} \>   Borrar caracter (P*)\\
delete\_line                \> {\tt dl1}       \> {\tt dl} \>   Borrar l\a'{\i}nea (P*)\\
device\_type                \> {\tt devt}      \> {\tt dv} \>   Indica soporte de idioma/conjuto de c\a'odigo\\
dis\_status\_line           \> {\tt dsl}       \> {\tt ds} \>   Desactiva l\a'{\i}nea de estado\\
display\_pc\_char           \> {\tt dispc}     \> {\tt S1} \>   Imprime el caracter pc\\
down\_half\_line            \> {\tt hd}        \> {\tt hd} \>   Baja media l\a'{\i}nea (1/2 avance de l\a'{\i}nea hacia delante)\\
ena\_acs                    \> {\tt enacs}     \> {\tt eA} \>   activa conjunto de car. altern.\\
end\_bit\_image\_region     \> {\tt endbi}     \> {\tt Yy} \>   Fin de regi\a'on de imagen por bits (usar tparm)\\
enter\_alt\_charset\_mode   \> {\tt smacs}     \> {\tt as} \>   Comienza un conjunto de caracteres alternativo (P)\\
enter\_am\_mode             \> {\tt smam}      \> {\tt SA} \>   Activa m\a'argenes autom\a'aticos\\
enter\_blink\_mode          \> {\tt blink}     \> {\tt mb} \>   Activa caracteres intermitentes\\
enter\_bold\_mode           \> {\tt bold}      \> {\tt md} \>   Activa el modo
negrita(de brillo extra)\\
enter\_ca\_mode             \> {\tt smcup}     \> {\tt ti} \>   Cadena al principio de los programas que usen cup\\
enter\_delete\_mode         \> {\tt smdc}      \> {\tt dm} \>   Modo de borrado (avtivado)\\
enter\_dim\_mode            \> {\tt dim}       \> {\tt mh} \>   Activa el modo de menor brillo\\
enter\_doublewide\_mode     \> {\tt swidm}     \> {\tt ZF} \>   Activa el modo de doble ancho\\
enter\_draft\_quality       \> {\tt sdrfq}     \> {\tt ZG} \>   Activa el modo de calidad de borrador\\
enter\_insert\_mode         \> {\tt smir}      \> {\tt im} \>   Activa el modo de inserci\a'on (activado);\\
enter\_italics\_mode        \> {\tt sitm}      \> {\tt ZH} \>   Activa el modo en cursiva\\
enter\_leftward\_mode       \> {\tt slm}       \> {\tt ZI} \>   Activa el movimiento del carro hacia la izquierda\\
enter\_micro\_mode          \> {\tt smicm}     \> {\tt ZJ} \>   Activa los atributos de micro-movimiento\\
enter\_near\_letter\_quality\> {\tt snlq}      \> {\tt ZK} \>   Activa impresi\a'on NLQ\\
enter\_normal\_quality      \> {\tt snrmq}     \> {\tt ZL} \>   Activa modo de impresi\a'on de calidad normal\\
enter\_pc\_charset\_mode    \> {\tt smpch}     \> {\tt S2} \>   Activa el modo de impresi\a'on del conjunto de caracteres PC\\
enter\_protected\_mode      \> {\tt prot}      \> {\tt mp} \>   Activa el modo protegido\\
enter\_reverse\_mode        \> {\tt rev}       \> {\tt mr} \>   Activa el modo de video inverso\\
enter\_scancode\_mode       \> {\tt smsc}      \> {\tt S4} \>   Activa el modo de codig\a'os de escaneado de PC\\
enter\_secure\_mode         \> {\tt invis}     \> {\tt mk} \>   Activa el modo vac\a'{\i}o (caracteres invisibles)\\
enter\_shadow\_mode         \> {\tt sshm}      \> {\tt ZM} \>   Activa la impresi\a'on en modo de sombra\\
enter\_standout\_mode       \> {\tt smso}      \> {\tt so} \>   Activa el modo destacado\\
enter\_subscript\_mode      \> {\tt ssubm}     \> {\tt ZN} \>   Activa el modo de sub\a'{\i}ndice\\
enter\_superscript\_mode    \> {\tt ssupm}     \> {\tt ZO} \>   Activa el modo de super\a'{\i}ndice\\
enter\_underline\_mode      \> {\tt smul}      \> {\tt us} \>   Comienza el modo de subrayado\\
enter\_upward\_mode         \> {\tt sum}       \> {\tt ZP} \>   Permite el movimiento hacia arriba del carro\\
enter\_xon\_mode            \> {\tt smxon}     \> {\tt SX} \>   Activa el protocolo xon/xoff\\
erase\_chars                \> {\tt ech}       \> {\tt ec} \>   Borra \#1 caracteres (PG)\\
exit\_alt\_charset\_mode    \> {\tt rmacs}     \> {\tt ae} \>   Fin de conjunto de caracteres alternativo (P)\\
exit\_am\_mode              \> {\tt rmam}      \> {\tt RA} \>   Desactiva los m\a'argenes autom\a'aticos\\
exit\_attribute\_mode       \> {\tt sgr0}      \> {\tt me} \>   Desactiva todos los atributos\\
exit\_ca\_mode              \> {\tt rmcup}     \> {\tt te} \>   Cadena para terminar los programas que usan cup\\
exit\_delete\_mode          \> {\tt rmdc}      \> {\tt ed} \>   Fin del modo de borrado\\
exit\_doublewide\_mode      \> {\tt rwidm}     \> {\tt ZQ} \>   Desactiva la impresi\a'on en doble ancho\\
exit\_insert\_mode          \> {\tt rmir}      \> {\tt ei} \>   Fin del modo de inserci\a'on\\
exit\_italics\_mode         \> {\tt ritm}      \> {\tt ZR} \>   Desactiva la impresi\a'on de cursiva\\
exit\_leftward\_mode        \> {\tt rlm}       \> {\tt ZS} \>   Activa el movimiento del carro (normal) hacia\\
                            \>                 \>          \>   la derecha\\
exit\_micro\_mode           \> {\tt rmicm}     \> {\tt ZT} \>   Desactiva la capacidad de micro movimiento\\
exit\_pc\_charset\_mode     \> {\tt rmpch}     \> {\tt S3} \>   Desactiva la impresi\a'on de caracteres PC\\
exit\_scancode\_mode        \> {\tt rmsc}      \> {\tt S5} \>   Desactiva el modo de escaneado de c\a'odigos PC\\
exit\_shadow\_mode          \> {\tt rshm}      \> {\tt ZU} \>   Deactiva la impresi\a'on en modo sombra\\
exit\_standout\_mode        \> {\tt rmso}      \> {\tt se} \>   Fin del modo destacado\\
exit\_subscript\_mode       \> {\tt rsubm}     \> {\tt ZV} \>   Desatciva la impresi\a'on de sub\a'{\i}ndices\\
exit\_superscript\_mode     \> {\tt rsupm}     \> {\tt ZW} \>   Desatciva la impresi\a'on de super\a'{\i}ndices\\
exit\_underline\_mode       \> {\tt rmul}      \> {\tt ue} \>   Fin del modo de subrayado\\
exit\_upward\_mode          \> {\tt rum}       \> {\tt ZX} \>   Permite el movimiento del carro (normal) hacia\\
                            \>                 \>          \>   abajo\\
exit\_xon\_mode             \> {\tt rmxon}     \> {\tt RX} \>   Desactiva el protocolo xon/xoff\\
flash\_screen               \> {\tt flash}     \> {\tt vb} \>   Timbre visible (puede que no mueva el cursor)\\
form\_feed                  \> {\tt ff}        \> {\tt ff} \>   Expulsi\a'on de p\a'agina en terminal de impresi\a'on (P*)\\
from\_status\_line          \> {\tt fsl}       \> {\tt fs} \>   Retorno desde la l\a'{\i}nea de estado\\
init\_1string               \> {\tt is1}       \> {\tt i1} \>   Cadena de inicializaci\a'on de la terminal\\
init\_2string               \> {\tt is2}       \> {\tt i2} \>   Cadena de inicializaci\a'on de la terminal\\
init\_3string               \> {\tt is3}       \> {\tt i3} \>   Cadena de inicializaci\a'on de la terminal\\
init\_file                  \> {\tt if}        \> {\tt if} \>   Nombre del fichero que contiene es\\
init\_prog                  \> {\tt iprog}     \> {\tt iP} \>   Ruta del programa de inicio\\
initialize\_color           \> {\tt initc}     \> {\tt Ic} \>   Inicia la definici\a'on de color\\
initialize\_pair            \> {\tt initp}     \> {\tt Ip} \>   Inicializa una pareja de colores\\
insert\_character           \> {\tt ich1}      \> {\tt ic} \>   A~nadir caracter (P)\\
insert\_line                \> {\tt il1}       \> {\tt al} \>   A~nadir una l\a'{\i}nea vac\a'{\i}a (P*)\\
insert\_padding             \> {\tt ip}        \> {\tt ip} \>   A~nadir relleno despu\a'es de caracter nuevo (p*)\\
key\_a1         \> {\tt ka1}    \> {\tt K1} \>   Superior izquierda en el teclado num\a'erico\\
key\_a3         \> {\tt ka3}    \> {\tt K3} \>   Superior derecha en el teclado num\a'erico\\
key\_b2         \> {\tt kb2}    \> {\tt K2} \>   Centro del teclado num\a'erico\\
key\_backspace  \> {\tt kbs}    \> {\tt kb} \>   Enviado por el retroceso\\
key\_beg        \> {\tt kbeg}   \> {\tt \@1}\>   Tecla de comienzo\\
key\_btab       \> {\tt kcbt}   \> {\tt kB} \>   Tabulador inverso\\
key\_c1         \> {\tt kc1}    \> {\tt K4} \>   Inferior izquierda en el teclado num\a'erico\\
key\_c3         \> {\tt kc3}    \> {\tt K5} \>   Inferior derecha en el teclado num\a'erico\\
key\_cancel     \> {\tt kcan}   \> {\tt \@2}\>   Tecla de cancelaci\a'on\\
key\_catab      \> {\tt ktbc}   \> {\tt ka} \>   Enviado por la tecla de borrado de tabuladores\\
key\_clear      \> {\tt kclr}   \> {\tt kC} \>   Enviado por el borrado de pantalla o la tecla de borrado\\
key\_close      \> {\tt kclo}   \> {\tt \@3}\>   Tecla de cerrado\\
key\_command    \> {\tt kcmd}   \> {\tt \@4}\>   Tecla de \a'orden\\
key\_copy       \> {\tt kcpy}   \> {\tt \@5}\>   Tecla de copiado\\
key\_create     \> {\tt kcrt}   \> {\tt \@6}\>   Tecla de creaci\a'on\\
key\_ctab       \> {\tt kctab}  \> {\tt kt} \>   Enviado por borrado de tabulador\\
key\_dc         \> {\tt kdch1}  \> {\tt kD} \>   Enviado por la tecla de borrado de caracter\\
key\_dl         \> {\tt kdl1}   \> {\tt kL} \>   Enviado por la tecla de borrado de l\a'{\i}nea\\
key\_down       \> {\tt kcud1}  \> {\tt kd} \>   Enviado por la flecha hacia abajo\\
key\_eic        \> {\tt krmir}  \> {\tt kM} \>   Enviado por rmir o smir en modo de inserci\a'on\\
key\_end        \> {\tt kend}   \> {\tt \@7}\>   Fin\\
key\_enter      \> {\tt kent}   \> {\tt \@8}\>   enter/env\a'{\i}o\\
key\_eol        \> {\tt kel}    \> {\tt kE} \>   Enviado por borrado hasta final de l\a'{\i}nea\\
key\_eos        \> {\tt ked}    \> {\tt kS} \>   Enviado por borrado hasta fin de pantalla\\
key\_exit       \> {\tt kext}   \> {\tt \@9}\>   Tecla de salida
\end{tabbing}
\begin{multicols}{2}
\begin{tabbing}
1234567890\=12345\=67890\=1234567890123456790\kill
key\_f0         \> {\tt kf0}    \> {\tt k0} \>   Tecla de funci\a'on F00\\
key\_f1         \> {\tt kf1}    \> {\tt k1} \>   Tecla de funci\a'on F01\\
key\_f2         \> {\tt kf2}    \> {\tt k2} \>   Tecla de funci\a'on F02\\
key\_f3         \> {\tt kf3}    \> {\tt k3} \>   Tecla de funci\a'on F03\\
key\_f4         \> {\tt kf4}    \> {\tt k4} \>   Tecla de funci\a'on F04\\
key\_f5         \> {\tt kf5}    \> {\tt k5} \>   Tecla de funci\a'on F05\\
key\_f6         \> {\tt kf6}    \> {\tt k6} \>   Tecla de funci\a'on F06\\
key\_f7         \> {\tt kf7}    \> {\tt k7} \>   Tecla de funci\a'on F07\\
key\_f8         \> {\tt kf8}    \> {\tt k8} \>   Tecla de funci\a'on F08\\
key\_f9         \> {\tt kf9}    \> {\tt k9} \>   Tecla de funci\a'on F09\\
key\_f10        \> {\tt kf10}   \> {\tt k;} \>   Tecla de funci\a'on F10\\
key\_f11        \> {\tt kf11}   \> {\tt F1} \>   Tecla de funci\a'on F11\\
key\_f12        \> {\tt kf12}   \> {\tt F2} \>   Tecla de funci\a'on F12\\
key\_f13        \> {\tt kf13}   \> {\tt F3} \>   Tecla de funci\a'on F13\\
key\_f14        \> {\tt kf14}   \> {\tt F4} \>   Tecla de funci\a'on F14\\
key\_f15        \> {\tt kf15}   \> {\tt F5} \>   Tecla de funci\a'on F15\\
key\_f16        \> {\tt kf16}   \> {\tt F6} \>   Tecla de funci\a'on F16\\
key\_f17        \> {\tt kf17}   \> {\tt F7} \>   Tecla de funci\a'on F17\\
key\_f18        \> {\tt kf18}   \> {\tt F8} \>   Tecla de funci\a'on F18\\
key\_f19        \> {\tt kf19}   \> {\tt F9} \>   Tecla de funci\a'on F19\\
key\_f20        \> {\tt kf20}   \> {\tt FA} \>   Tecla de funci\a'on F20\\
key\_f21        \> {\tt kf21}   \> {\tt FB} \>   Tecla de funci\a'on F21\\
key\_f22        \> {\tt kf22}   \> {\tt FC} \>   Tecla de funci\a'on F22\\
key\_f23        \> {\tt kf23}   \> {\tt FD} \>   Tecla de funci\a'on F23\\
key\_f24        \> {\tt kf24}   \> {\tt FE} \>   Tecla de funci\a'on F24\\
key\_f25        \> {\tt kf25}   \> {\tt FF} \>   Tecla de funci\a'on F25\\
key\_f26        \> {\tt kf26}   \> {\tt FG} \>   Tecla de funci\a'on F26\\
key\_f27        \> {\tt kf27}   \> {\tt FH} \>   Tecla de funci\a'on F27\\
key\_f28        \> {\tt kf28}   \> {\tt FI} \>   Tecla de funci\a'on F28\\
key\_f29        \> {\tt kf29}   \> {\tt FJ} \>   Tecla de funci\a'on F29\\
key\_f30        \> {\tt kf30}   \> {\tt FK} \>   Tecla de funci\a'on F30\\
key\_f31        \> {\tt kf31}   \> {\tt FL} \>   Tecla de funci\a'on F31\\
key\_f32        \> {\tt kf32}   \> {\tt FM} \>   Tecla de funci\a'on F32\\
key\_f33        \> {\tt kf33}   \> {\tt FN} \>   Tecla de funci\a'on F33\\
key\_f34        \> {\tt kf34}   \> {\tt FO} \>   Tecla de funci\a'on F34\\
key\_f35        \> {\tt kf35}   \> {\tt FP} \>   Tecla de funci\a'on F35\\
key\_f36        \> {\tt kf36}   \> {\tt FQ} \>   Tecla de funci\a'on F36\\
key\_f37        \> {\tt kf37}   \> {\tt FR} \>   Tecla de funci\a'on F37\\
key\_f38        \> {\tt kf38}   \> {\tt FS} \>   Tecla de funci\a'on F38\\
key\_f39        \> {\tt kf39}   \> {\tt FT} \>   Tecla de funci\a'on F39\\
key\_f40        \> {\tt kf40}   \> {\tt FU} \>   Tecla de funci\a'on F40\\
key\_f41        \> {\tt kf41}   \> {\tt FV} \>   Tecla de funci\a'on F41\\
key\_f42        \> {\tt kf42}   \> {\tt FW} \>   Tecla de funci\a'on F42\\
key\_f43        \> {\tt kf43}   \> {\tt FX} \>   Tecla de funci\a'on F43\\
key\_f44        \> {\tt kf44}   \> {\tt FY} \>   Tecla de funci\a'on F44\\
key\_f45        \> {\tt kf45}   \> {\tt FZ} \>   Tecla de funci\a'on F45\\
key\_f46        \> {\tt kf46}   \> {\tt Fa} \>   Tecla de funci\a'on F46\\
key\_f47        \> {\tt kf47}   \> {\tt Fb} \>   Tecla de funci\a'on F47\\
key\_f48        \> {\tt kf48}   \> {\tt Fc} \>   Tecla de funci\a'on F48\\
key\_f49        \> {\tt kf49}   \> {\tt Fd} \>   Tecla de funci\a'on F49\\
key\_f50        \> {\tt kf50}   \> {\tt Fe} \>   Tecla de funci\a'on F50\\
key\_f51        \> {\tt kf51}   \> {\tt Ff} \>   Tecla de funci\a'on F51\\
key\_f52        \> {\tt kf52}   \> {\tt Fg} \>   Tecla de funci\a'on F52\\
key\_f53        \> {\tt kf53}   \> {\tt Fh} \>   Tecla de funci\a'on F53\\
key\_f54        \> {\tt kf54}   \> {\tt Fi} \>   Tecla de funci\a'on F54\\
key\_f55        \> {\tt kf55}   \> {\tt Fj} \>   Tecla de funci\a'on F55\\
key\_f56        \> {\tt kf56}   \> {\tt Fk} \>   Tecla de funci\a'on F56\\
key\_f57        \> {\tt kf57}   \> {\tt Fl} \>   Tecla de funci\a'on F57\\
key\_f58        \> {\tt kf58}   \> {\tt Fm} \>   Tecla de funci\a'on F58\\
key\_f59        \> {\tt kf59}   \> {\tt Fn} \>   Tecla de funci\a'on F59\\
key\_f60        \> {\tt kf60}   \> {\tt Fo} \>   Tecla de funci\a'on F60\\
key\_f61        \> {\tt kf61}   \> {\tt Fp} \>   Tecla de funci\a'on F61\\
key\_f62        \> {\tt kf62}   \> {\tt Fq} \>   Tecla de funci\a'on F62\\
key\_f63        \> {\tt kf63}   \> {\tt Fr} \>   Tecla de funci\a'on F63
\end{tabbing}
\end{multicols}
\begin{tabbing}
12345678901234567890123\=456123456\=78901\=4567890\kill
key\_find       \> {\tt kfnd}   \> {\tt \@0}\>   Tecla de b\a'usqueda\\
key\_help       \> {\tt khlp}   \> {\tt \%1}\>   Tecla de ayuda\\
key\_home       \> {\tt khome}  \> {\tt kh} \>   Enviado por la tecla de Inicio\\
key\_ic         \> {\tt kich1}  \> {\tt kI} \>   Enviado por la tecla de Inserci\a'on\\
key\_il         \> {\tt kil1}   \> {\tt kA} \>   Enviado por insertar l\a'{\i}nea\\
key\_left       \> {\tt kcub1}  \> {\tt kl} \>   Enviado por la flecha izquierda\\
key\_ll         \> {\tt kll}    \> {\tt kH} \>   Enviado por la tecla home-down\\
key\_mark       \> {\tt kmrk}   \> {\tt \%2}\>   Tecla de marcar\\
key\_message    \> {\tt kmsg}   \> {\tt \%3}\>   Tecla de mensaje\\
key\_move       \> {\tt kmov}   \> {\tt \%4}\>   Tecla de movimiento\\
key\_next       \> {\tt knxt}   \> {\tt \%5}\>   Tecla "siguiente"\\
key\_npage      \> {\tt knp}    \> {\tt kN} \>   Enviado por la tecla de p\a'agina siguiente\\
key\_open       \> {\tt kopn}   \> {\tt \%6}\>   Tecla de apertura\\
key\_options    \> {\tt kopt}   \> {\tt \%7}\>   Tecla de opciones\\
key\_ppage      \> {\tt kpp}    \> {\tt kP} \>   Enviado por la tecla de p\a'agina previa\\
key\_previous   \> {\tt kprv}   \> {\tt \%8}\>   Tecla previa\\
key\_print      \> {\tt kprt}   \> {\tt \%9}\>   Tecla de impresi\a'on\\
key\_redo       \> {\tt krdo}   \> {\tt \%0}\>   Tecla de repetici\a'on\\
key\_reference  \> {\tt kref}   \> {\tt \&1}\>   Tecla de referencia\\
key\_refresh    \> {\tt krfr}   \> {\tt \&2}\>   Tecla de refresco\\
key\_replace    \> {\tt krpl}   \> {\tt \&3}\>   Tecla de reemplazamiento\\
key\_restart    \> {\tt krst}   \> {\tt \&4}\>   Tecla de reinicio\\
key\_resume     \> {\tt kres}   \> {\tt \&5}\>   Tecla de continuaci\a'on\\
key\_right      \> {\tt kcuf1}  \> {\tt kr} \>   Enviado por la tecla de flecha derecha\\
key\_save       \> {\tt ksav}   \> {\tt \&6}\>   Tecla de grabado\\
key\_sbeg       \> {\tt kBEG}   \> {\tt \&9}\>   May\a'us. + tecla de comienzo\\
key\_scancel    \> {\tt kCAN}   \> {\tt \&0}\>   May\a'us. + cancelaci\a'on\\
key\_scommand   \> {\tt kCMD}   \> {\tt *1} \>   May\a'us. + tecla de \a'orden\\
key\_scopy      \> {\tt kCPY}   \> {\tt *2} \>   May\a'us. + tecla de copiado\\
key\_screate    \> {\tt kCRT}   \> {\tt *3} \>   May\a'us. + tecla de creaci\a'on\\
key\_sdc        \> {\tt kDC}    \> {\tt *4} \>   May\a'us. + suprimir\\
key\_sdl        \> {\tt kDL}    \> {\tt *5} \>   May\a'us. + suprimir l\a'{\i}nea\\
key\_select     \> {\tt kslt}   \> {\tt *6} \>   Tecla de selecci\a'on\\
key\_send       \> {\tt kEND}   \> {\tt *7} \>   May\a'us. + fin\\
key\_seol       \> {\tt kEOL}   \> {\tt *8} \>   May\a'us. + final de l\a'{\i}nea\\
key\_sexit      \> {\tt kEXT}   \> {\tt *9} \>   May\a'us. + sal\a'{\i}da\\
key\_sf         \> {\tt kind}   \> {\tt kF} \>   Enviado por la tecla de avance\\
key\_sfind      \> {\tt kFND}   \> {\tt *0} \>   May\a'us. + tecla de b\a'usqueda\\
key\_shelp      \> {\tt kHLP}   \> {\tt \#1}\>   May\a'us. + tecla de ayuda\\
key\_shome      \> {\tt kHOM}   \> {\tt \#2}\>   May\a'us. + inicio\\
key\_sic        \> {\tt kIC}    \> {\tt \#3}\>   May\a'us. + tecla de inserci\a'on\\
key\_sleft      \> {\tt kLFT}   \> {\tt \#4}\>   May\a'us. + izquierda\\
key\_smessage   \> {\tt kMSG}   \> {\tt \%a}\>   May\a'us. + tecla de mensaje\\
key\_smove      \> {\tt kMOV}   \> {\tt \%b}\>   May\a'us. + tecla de movimiento\\
key\_snext      \> {\tt kNXT}   \> {\tt \%c}\>   May\a'us. + "siguiente"\\
key\_soptions   \> {\tt kOPT}   \> {\tt \%d}\>   May\a'us. + tecla de opciones\\
key\_sprevious  \> {\tt kPRV}   \> {\tt \%e}\>   May\a'us. + previo\\
key\_sprint     \> {\tt kPRT}   \> {\tt \%f}\>   May\a'us. + tecla de impresi\a'on\\
key\_sr         \> {\tt kri}    \> {\tt kR} \>   Enviado por la tecla de desplazamiento hacia atr\a'as\\
key\_sredo      \> {\tt kRDO}   \> {\tt \%g}\>   May\a'us. + tecla de repetici\a'on\\
key\_sreplace   \> {\tt kRPL}   \> {\tt \%h}\>   May\a'us. + tecla de substituci\a'on\\
key\_sright     \> {\tt kRIT}   \> {\tt \%i}\>   May\a'us. + derecha\\
key\_srsume     \> {\tt kRES}   \> {\tt \%j}\>   May\a'us. + tecla de continuaci\a'on\\
key\_ssave      \> {\tt kSAV}   \> {\tt !1} \>   May\a'us. + tecla de grabado\\
key\_ssuspend   \> {\tt kSPD}   \> {\tt !2} \>   May\a'us. + tecla de suspensi\a'on\\
key\_stab       \> {\tt khts}   \> {\tt kT} \>   Enviado por la tecla de fijaci\a'on de tabulador\\
key\_sundo      \> {\tt kUND}   \> {\tt !3} \>   May\a'us. + deshacer\\
key\_suspend    \> {\tt kspd}   \> {\tt \&7}\>   Suspensi\a'on\\
key\_undo       \> {\tt kund}   \> {\tt \&8}\>   Deshacer\\
key\_up         \> {\tt kcuu1}  \> {\tt ku} \>   Enviado por la flecha hacia arriba\\
keypad\_local   \> {\tt rmkx}   \> {\tt ke} \>   Salida del modo de transmisi\a'on de teclas num\a'ericas\\
keypad\_xmit    \> {\tt smkx}   \> {\tt ks} \>   Poner la terminal en modo de transmisi\a'on de teclas num\a'ericas\\
lab\_f0         \> {\tt lf0}    \> {\tt l0} \>   Etiqueta de la  funci\a'on f0 si no es f0\\
lab\_f1         \> {\tt lf1}    \> {\tt l1} \>   Etiqueta de la  funci\a'on f1 si no es f1\\
lab\_f2         \> {\tt lf2}    \> {\tt l2} \>   Etiqueta de la  funci\a'on f2 si no es f2\\
lab\_f3         \> {\tt lf3}    \> {\tt l3} \>   Etiqueta de la  funci\a'on f3 si no es f3\\
lab\_f4         \> {\tt lf4}    \> {\tt l4} \>   Etiqueta de la  funci\a'on f4 si no es f4\\
lab\_f5         \> {\tt lf5}    \> {\tt l5} \>   Etiqueta de la  funci\a'on f5 si no es f5\\
lab\_f6         \> {\tt lf6}    \> {\tt l6} \>   Etiqueta de la  funci\a'on f6 si no es f6\\
lab\_f7         \> {\tt lf7}    \> {\tt l7} \>   Etiqueta de la  funci\a'on f7 si no es f7\\
lab\_f8         \> {\tt lf8}    \> {\tt l8} \>   Etiqueta de la  funci\a'on f8 si no es f8\\
lab\_f9         \> {\tt lf9}    \> {\tt l9} \>   Etiqueta de la  funci\a'on f9 si no es f9\\
lab\_f10        \> {\tt lf10}   \> {\tt la} \>   Etiqueta de la  funci\a'on f10 si no es f10\\
label\_on       \> {\tt smln}   \> {\tt LO} \>   Activa las etiquetas software\\
label\_off      \> {\tt rmln}   \> {\tt LF} \>   Desactiva las etiquetas software\\
meta\_off       \> {\tt rmm}    \> {\tt mo} \>   Desactiva el modo "meta"\\
meta\_on        \> {\tt smm}    \> {\tt mm} \>   Activa el modo "meta" (8 bit)\\
micro\_column\_address      \> {\tt mhpa}      \> {\tt ZY} \>   Igual que column\_address for micro adjustment\\
micro\_down                 \> {\tt mcud1}     \> {\tt ZZ} \>   Igual que cursor\_down for micro adjustment\\
micro\_left                 \> {\tt mcub1}     \> {\tt Za} \>   Igual que cursor\_left for micro adjustment\\
micro\_right                \> {\tt mcuf1}     \> {\tt Zb} \>   Igual que cursor\_right for micro adjustment\\
micro\_row\_address         \> {\tt mvpa}      \> {\tt Zc} \>   Igual que row\_address for micro adjustment\\
micro\_up                   \> {\tt mcuu1}     \> {\tt Zd} \>   Igual que cursor\_up for micro adjustment\\
newline                     \> {\tt nel}       \> {\tt nw} \>   Nueva l\a'{\i}nea (equivale a cr seguido de lf)\\
order\_of\_pins             \> {\tt porder}    \> {\tt Ze} \>   Matches software buts to print-head pins\\
orig\_colors                \> {\tt oc}        \> {\tt oc} \>   Resetea todas las parejas de color\\
orig\_pair                  \> {\tt op}        \> {\tt op} \>   Vuelve a establecer la pareja de color por defecto a su valor original\\
pad\_char                   \> {\tt pad}       \> {\tt pc} \>   Caracter de relleno (en vez del nulo)\\
parm\_dch                   \> {\tt dch}       \> {\tt DC} \>   Borra \#1 caracteres (PG*)\\
parm\_delete\_line          \> {\tt dl}        \> {\tt DL} \>   Borra \#1 l\a'{\i}neas (PG*)\\
parm\_down\_cursor          \> {\tt cud}       \> {\tt DO} \>   Desplaza el cursor hacia abajo \#1 l\a'{\i}neas (PG*)\\
parm\_down\_micro           \> {\tt mcud}      \> {\tt Zf} \>   Igual que cud para micro ajustes\\
parm\_ich                   \> {\tt ich}       \> {\tt IC} \>   A~nadir \#1 caracteres vac\a'{\i}os (PG*)\\
parm\_index                 \> {\tt indn}      \> {\tt SF} \>   Avanza \#1 l\a'{\i}neas (PG)\\
parm\_insert\_line          \> {\tt il}        \> {\tt AL} \>   A~nadir \#1 l\a'{\i}neas vac\a'{\i}as (PG*)\\
parm\_left\_cursor          \> {\tt cub}       \> {\tt LE} \>   Mueve el cursor hacia la izquierda \#1 espacios (PG)\\
parm\_left\_micro           \> {\tt mcub}      \> {\tt Zg} \>   Igual que cul para micro ajustes\\
parm\_right\_cursor         \> {\tt cuf}       \> {\tt RI} \>   Mueve el cursor hacia la derecha \#1 espacios (PG*)\\
parm\_right\_micro          \> {\tt mcuf}      \> {\tt Zh} \>   Igual que cuf para micro ajustes\\
parm\_rindex                \> {\tt rin}       \> {\tt SR} \>   Retrocede \#1 l\a'{\i}neas (PG)\\
parm\_up\_cursor            \> {\tt cuu}       \> {\tt UP} \>   Mueve el cursor \#1 l\a'{\i}neas hacia arriba (PG*)\\
parm\_up\_micro             \> {\tt mcuu}      \> {\tt Zi} \>   Igual que cuu para micro ajustes\\
pkey\_key                   \> {\tt pfkey}     \> {\tt pk} \>   Programa funci\a'on \#1 para imprimir la cadena \#2\\
pkey\_local                 \> {\tt pfloc}     \> {\tt pl} \>   Programa funci\a'on \#1 para ejecutar la cadena \#2\\
pkey\_xmit                  \> {\tt pfx}       \> {\tt px} \>   Programa funci\a'on \#1 para transmitir la cadena \#2\\
pkey\_plab                  \> {\tt pfxl}      \> {\tt xl} \>   Programa la tecla \#1 para transmitir \#2 e imprimir \#3\\
plab\_norm                  \> {\tt pln}       \> {\tt pn} \>   Programa la etiqueta \#1 para imprimir la cadena \#2\\
print\_screen               \> {\tt mc0}       \> {\tt ps} \>   Imprime el contenido de la pantalla\\
prtr\_non                   \> {\tt mc5p}      \> {\tt pO} \>   Activa la impresora para \#1 bytes\\
prtr\_off                   \> {\tt mc4}       \> {\tt pf} \>   Desacitva la impresora\\
prtr\_on                    \> {\tt mc5}       \> {\tt po} \>   Activa la impresora\\
repeat\_char                \> {\tt rep}       \> {\tt rp} \>   Repite el caracter \#1 \#2 veces.  (PG*)\\
req\_for\_input             \> {\tt rfi}       \> {\tt RF} \>   Petici\a'on de entrada\\
reset\_1string              \> {\tt rs1}       \> {\tt r1} \>   Pone la terminal el modos normales.\\
reset\_2string              \> {\tt rs2}       \> {\tt r2} \>   Pone la terminal el modos normales.\\
reset\_3string              \> {\tt rs3}       \> {\tt r3} \>   Pone la terminal el modos normales.\\
reset\_file                 \> {\tt rf}        \> {\tt rf} \>   Nombre del fichero con la cadena de reset\\
restore\_cursor             \> {\tt rc}        \> {\tt rc} \>   Devuelve el cursor a la posici\a'on del \a'ultimo sc\\
row\_address                \> {\tt vpa}       \> {\tt cv} \>   Posici\a'on vertical absoluta (fija la fila) (PG)\\
save\_cursor                \> {\tt sc}        \> {\tt sc} \>   Salvado del cursor (P)\\
scancode\_escape            \> {\tt scesc}     \> {\tt S7} \>   Escape para la emulaci\a'on de c\a'odigo de escaneado\\
scroll\_forward             \> {\tt ind}       \> {\tt sf} \>   Avanza el texto hacia arriba (P)\\
scroll\_reverse             \> {\tt ri}        \> {\tt sr} \>   Avanza el texto hacia abajo (P)\\
select\_char\_set           \> {\tt scs}       \> {\tt Zj} \>   Selecciona el c\a'odigo de caracteres\\
set0\_des\_seq              \> {\tt s0ds}      \> {\tt s0} \>   Utilizar el conjunto de c\a'odigos 0 (EUC conjunto 0, ASCII)\\
set1\_des\_seq              \> {\tt s1ds}      \> {\tt s1} \>   Utilizar el conjunto de c\a'odigos 1\\
set2\_des\_seq              \> {\tt s2ds}      \> {\tt s2} \>   Utilizar el conjunto de c\a'odigos 2\\
set3\_des\_seq              \> {\tt s3ds}      \> {\tt s3} \>   Utilizar el conjunto de c\a'odigos 3\\
set\_a\_background          \> {\tt setab}     \> {\tt AB} \>   Fijar el color del segundo plano usando una secuencia de escape ANSI\\
set\_a\_foreground          \> {\tt setaf}     \> {\tt AF} \>   Fijar el color del primer plano usando una secuencia de escape ANSI\\
set\_attributes             \> {\tt sgr}       \> {\tt sa} \>   Definir los atributos de v\a'{\i}deo (PG9)\\
set\_background             \> {\tt setb}      \> {\tt Sb} \>   Fijar el color del segundo plano\\
set\_bottom\_margin         \> {\tt smgb}      \> {\tt Zk} \>   Fijar el margen inferior en esta l\a'{\i}nea\\
set\_bottom\_margin\_parm   \> {\tt smgbp}     \> {\tt Zl} \>   Fijar el margen inferior en la l\a'{\i}nea \#1 o a \#2\\
                            \>                 \>          \>   l\a'{\i}neas del final\\
set\_color\_band            \> {\tt setcolor}  \> {\tt Yz} \>   Cambia a la cinta de color \#1\\
set\_color\_pair            \> {\tt scp}       \> {\tt sp} \>   Fijar la pareja de colores\\
set\_foreground             \> {\tt setf}      \> {\tt Sf} \>   Fijar el color del primer plano\\
set\_left\_margin           \> {\tt smgl}      \> {\tt ML} \>   Fijar el margen izquierdo en esta columna\\
set\_left\_margin\_parm     \> {\tt smglp}     \> {\tt Zm} \>   Fijar el margen izquierdo (derecho) en \#1 (\#2)\\
set\_lr\_margin             \> {\tt smglr}     \> {\tt ML} \>   Fijar los m\a'argenes izquierdo y derecho\\
set\_page\_length           \> {\tt slines}    \> {\tt YZ} \>   Fijar la longitud de la p\a'agina  en \#1 l\a'{\i}neas (usar tparm)\\
set\_right\_margin          \> {\tt smgr}      \> {\tt MR} \>   Fijar el margen derecho en esta columna\\
set\_right\_margin\_parm    \> {\tt smgrp}     \> {\tt Zn} \>   Fijar el margen derecho en la columna \#1\\
set\_tab                    \> {\tt hts}       \> {\tt st} \>   Fijar una parada del tabulador en esta columna en todas las filas\\
set\_tb\_margin             \> {\tt smgtb}     \> {\tt MT} \>   Fijar los m\a'argenes superior e inferior\\
set\_top\_margin            \> {\tt smgt}      \> {\tt Zo} \>   Fijar el margen superior en esta l\a'{\i}nea\\
set\_top\_margin\_parm      \> {\tt smgtp}     \> {\tt Zp} \>   Fijar el margen superior en la l\a'{\i}nea \#1\\
set\_window                 \> {\tt wind}      \> {\tt wi} \>   Esta ventana est\a'a entre las l\a'{\i}neas \#1-\#2 y las columnas \#3-\#4\\
start\_bit\_image           \> {\tt sbim}      \> {\tt Zq} \>   Comenzar la impresi\a'on de imagen de bits\\
start\_char\_set\_def       \> {\tt scsd}      \> {\tt Zr} \>   Comenazar la definici\a'on de un conjunto de caracteres\\
stop\_bit\_image            \> {\tt rbim}      \> {\tt Zs} \>   Fin de impresi\a'on de imagen de bits\\
stop\_char\_set\_def        \> {\tt rcsd}      \> {\tt Zt} \>   Fin de la definicion de un conjunto de caracteres\\
subscript\_characters       \> {\tt subcs}     \> {\tt Zu} \>   Lista de caracteres que pueden ser sub\a'{\i}ndices\\
superscript\_characters     \> {\tt supcs}     \> {\tt Zv} \>   Lista de caracteres que pueden ser super\a'{\i}ndices\\
tab                         \> {\tt ht}        \> {\tt ta} \>   Desplazarse hasta la siguiente parada de tabulador (en espacios de a ocho)\\
these\_cause\_cr            \> {\tt docr}      \> {\tt Zw} \>   Estos caracteres causan un CR\\
to\_status\_line            \> {\tt tsl}       \> {\tt ts} \>   Desplazarse hasta la l\a'{\i}nea de estado, columna \#1\\
underline\_char             \> {\tt uc}        \> {\tt uc} \>   Subrayar un caracter y situarse despu\a'es de \a'el\\
up\_half\_line              \> {\tt hu}        \> {\tt hu} \>   Desplazarse media l\a'{\i}nea hacia arriba (avance de 1/2 l\a'{\i}nea inverso)\\
xoff\_character             \> {\tt xoffc}     \> {\tt XF} \>   caracter XON\\
xon\_character              \> {\tt xonc}      \> {\tt XN} \>   caracter XOFF
\end{tabbing}

(Los siguientes atributos de cadena est\'an presentes en la estructura
term del SYSVr, aunque no est\'an documentados en la p\'agina de manual.
Los comentarios est\'an sacados de fichero de cabecera que define la
estructura term.)

\begin{tabbing}
12345678901234567890123\=456123456\=78901\=4567890\kill
label\_format               \> {\tt fln}     \> {\tt Lf} \>   ??\\
set\_clock                  \> {\tt sclk}    \> {\tt SC} \>   Fija el reloj\\
display\_clock              \> {\tt dclk}    \> {\tt DK} \>   Imprime el reloj\\
remove\_clock               \> {\tt rmclk}   \> {\tt RC} \>   Borra el reloj??\\
create\_window              \> {\tt cwin}    \> {\tt CW} \>   Define que la ventana \#1 va de \#2,\#3 a \#4,\#5\\
goto\_window                \> {\tt wingo}   \> {\tt WG} \>   Ir a la ventana \#1\\
hangup                      \> {\tt hup}     \> {\tt HU} \>   Colgar el tel\a'efono\\
dial\_phone                 \> {\tt dial}    \> {\tt DI} \>   Marcar el tel\a'efono \#1\\
quick\_dial                 \> {\tt qdial}   \> {\tt QD} \>   Marcar el tel\a'efono \#1, sin detectar\\
                            \>               \>          \>   como va la llamada\\
tone                        \> {\tt tone}    \> {\tt TO} \>   Elegir modo de marcado por tonos\\
pulse                       \> {\tt pulse}   \> {\tt PU} \>   Elegir modo de marcado por pulsos\\
flash\_hook                 \> {\tt hook}    \> {\tt fh} \>   Pulsar r\a'apidamente el interruptor de colgado\\
fixed\_pause                \> {\tt pause}   \> {\tt PA} \>   Pausa de 2-3 segundos\\
wait\_tone                  \> {\tt wait}    \> {\tt WA} \>   Esperar el tono de marcado\\
user0                       \> {\tt u0}      \> {\tt u0} \>   Cadena de usuario \# 0\\
user1                       \> {\tt u1}      \> {\tt u1} \>   Cadena de usuario \# 1\\
user2                       \> {\tt u2}      \> {\tt u2} \>   Cadena de usuario \# 2\\
user3                       \> {\tt u3}      \> {\tt u3} \>   Cadena de usuario \# 3\\
user4                       \> {\tt u4}      \> {\tt u4} \>   Cadena de usuario \# 4\\
user5                       \> {\tt u5}      \> {\tt u5} \>   Cadena de usuario \# 5\\
user6                       \> {\tt u6}      \> {\tt u6} \>   Cadena de usuario \# 6\\
user7                       \> {\tt u7}      \> {\tt u7} \>   Cadena de usuario \# 7\\
user8                       \> {\tt u8}      \> {\tt u8} \>   Cadena de usuario \# 8\\
user9                       \> {\tt u9}      \> {\tt u9} \>   Cadena de usuario \# 9\\
get\_mouse                  \> {\tt getm}    \> {\tt Gm} \>   Curses deber\a'{\i}a responder a los mensajes de botones\\
key\_mouse                  \> {\tt kmous}   \> {\tt Km} \>   ??\\
mouse\_info                 \> {\tt minfo}   \> {\tt Mi} \>   Informaci\a'on del estado del rat\a'on\\
pc\_term\_options           \> {\tt pctrm}   \> {\tt S6} \>   Opciones de terminal del PC\\
req\_mouse\_pos             \> {\tt reqmp}   \> {\tt RQ} \>   Petici\a'on de la posici\a'on del rat\a'on\\
zero\_motion                \> {\tt zerom}   \> {\tt Zx} \>   No desplazarse al detectar el siguiente caracter
\end{tabbing}
\end{small}




\section{Esquema de las Funciones de $[$N$]$Curses}

A continuaci\'on se puede ver un resumen de los diferentes paquetes (n)curses. La primera columna corresponde a la curses de bsd (que forma parte del slackware 2.1.0 y Sun-OS 4.x), en la segunda tenemos la curses del sysv (en Sun-OS 5.4 /Solaris 2) y la tercera es ncurses (versi\'on \ncver).

En la cuarta columna se encuentra un referencia a la p\'agina en la que se describe la funci\'on (si es que se describe en alg\'un lado).

\begin{itemize}
\item [x] el paquete tiene esta funci\'on.
\item [n] la funci\'on no ha sido implementada a\'un.
\end{itemize}

\begin{multicols}{2}
\begin{scriptsize}
\begin{tabbing}
12345678901234567890\=6789012\=3456790\=1234\=5678901234567890\kill
{\bf Funcion} \> {\bf BSD} \> {\bf SYSV} \> {\bf Nc.}    \> {\bf Pag.}\\
{\tt \_init\_trace()}            \>   \>   \> x   \>  \funref{fun__init_trace}       \\
{\tt \_traceattr(mode)}          \>   \>   \> x   \>  \funref{fun__traceattr}       \\
{\tt \_tracef(char *, ...)}      \>   \>   \> x   \>  \funref{fun__tracef}       \\
{\tt addbytes(...)}              \> x \>   \>     \>         \\
{\tt addch(ch)}                  \> x \> x \> x   \>  \funref{fun_addch}       \\
{\tt addchnstr(...)}             \>   \> x \> x   \>  \funref{fun_addchnstr}       \\
{\tt addchstr(chstr)}            \>   \> x \> x   \>  \funref{fun_addchstr}       \\
{\tt addnstr(...)}               \>   \> x \> x   \>  \funref{fun_addnstr}       \\  
{\tt addnwstr(...)}              \>   \> x \>     \>         \\
{\tt addstr(str)}                \> x \> x \> x   \>  \funref{fun_addstr}       \\
{\tt addwch(...)}                \>   \> x \>     \>         \\          
{\tt addwchnstr(...)}            \>   \> x \>     \>         \\          
{\tt addwchstr(...)}             \>   \> x \>     \>         \\          
{\tt addwstr(...)}               \>   \> x \>     \>         \\          
{\tt adjcurspos()}               \>   \> x \>     \>         \\       
{\tt attroff(attr)}              \>   \> x \> x   \>  \funref{fun_attroff}       \\
{\tt attron(attr)}               \>   \> x \> x   \>  \funref{fun_attron}       \\
{\tt attrset(attr)}              \>   \> x \> x   \>  \funref{fun_attrset}       \\
{\tt baudrate()}                 \> x \> x \> x   \>  \funref{fun_baudrate}       \\
{\tt beep()}                     \>   \> x \> x   \>  \funref{fun_beep}       \\
{\tt bkgd(ch)}                   \>   \> x \> x   \>  \funref{fun_bkgd}       \\
{\tt bkgdset(ch)}                \>   \> x \> x   \>  \funref{fun_bkgdset}       \\
{\tt border(...)}                \>   \> x \> x   \>  \funref{fun_border}       \\
{\tt box(...)}                   \> x \> x \> x   \>  \funref{fun_box}       \\
{\tt can\_change\_color()}       \>   \> x \> x   \>  \funref{fun_can_change_color}       \\
{\tt cbreak()}                   \> x \> x \> x   \>  \funref{fun_cbreak}       \\
{\tt clear()}                    \> x \> x \> x   \>  \funref{fun_clear}       \\
{\tt clearok(...)}               \> x \> x \> x   \>  \funref{fun_clearok}       \\
{\tt clrtobot()}                 \> x \> x \> x   \>  \funref{fun_clrtobot}       \\
{\tt clrtoeol()}                 \> x \> x \> x   \>  \funref{fun_clrtoeol}       \\
{\tt color\_content(...)}        \>   \> x \> x   \>  \funref{fun_color_content}       \\
{\tt copywin(...)}               \>   \> x \> x   \>  \funref{fun_copywin}       \\ 
{\tt crmode()}                   \> x \> x \> x   \>  \funref{fun_crmode}       \\
{\tt curs\_set(bf)}              \>   \> x \> x   \>  \funref{fun_curs_set}       \\
{\tt curserr()}                  \>   \> x \>     \>         \\
{\tt def\_prog\_mode()}          \>   \> x \> x   \>  \funref{fun_def_prog_mode}       \\
{\tt def\_shell\_mode()}         \>   \> x \> x   \>  \funref{fun_def_shell_mode}       \\
{\tt del\_curterm(...)}          \>   \> x \> x   \>  \funref{fun_del_curterm}       \\
{\tt delay\_output(ms)}          \>   \> x \> x   \>  \funref{fun_delay_output}       \\
{\tt delch()}                    \> x \> x \> x   \>  \funref{fun_delch}       \\
{\tt deleteln()}                 \> x \> x \> x   \>  \funref{fun_deleteln}       \\
{\tt delscreen(...)}             \>   \> x \> x,n \>  \funref{fun_delscreen}       \\
{\tt delwin(win)}                \> x \> x \> x   \>  \funref{fun_delwin}       \\
{\tt derwin(...)}                \>   \> x \> x   \>  \funref{fun_derwin}       \\
{\tt doupdate()}                 \>   \> x \> x   \>  \funref{fun_doupdate}       \\
{\tt drainio(int)}               \>   \> x \>     \>         \\
{\tt dupwin(win)}                \>   \> x \> x   \>  \funref{fun_dupwin}       \\
{\tt echo()}                     \> x \> x \> x   \>  \funref{fun_echo}       \\
{\tt echochar(ch)}               \>   \> x \> x   \>  \funref{fun_echochar}       \\
{\tt echowchar(ch)}              \>   \> x \>     \>         \\         
{\tt endwin()}                   \> x \> x \> x   \>  \funref{fun_endwin}       \\
{\tt erase()}                    \> x \> x \> x   \>  \funref{fun_erase}       \\
{\tt erasechar()}                \> x \> x \> x   \>  \funref{fun_erasechar}       \\
{\tt filter()}                   \>   \> x \> x   \>  \funref{fun_filter}       \\
{\tt flash()}                    \>   \> x \> x   \>  \funref{fun_flash}       \\
{\tt flushinp()}                 \>   \> x \> x   \>  \funref{fun_flushinp}       \\
{\tt flushok(...)}               \> x \>   \>     \>         \\
{\tt garbagedlines(...)}         \>   \> x \>     \>         \\
{\tt garbagedwin(win)}           \>   \> x \>     \>         \\
{\tt getattrs(win)}              \>   \> x \> x   \>  \funref{fun_getattrs}       \\
{\tt getbegyx(...)}              \>   \> x \> x   \>  \funref{fun_getbegyx}       \\
{\tt getbkgd(win)}               \>   \> x \>     \>         \\
{\tt getbmap()}                  \>   \> x \>     \>         \\
{\tt getcap(str)}                \> x \>   \>     \>         \\
{\tt getch()}                    \> x \> x \> x   \>  \funref{fun_getch}       \\
{\tt getmaxx(win)}               \>   \> x \> x   \>  \funref{fun_getmaxx}       \\
{\tt getmaxy(win)}               \>   \> x \> x   \>  \funref{fun_getmaxy}       \\
{\tt getmaxyx(...)}              \>   \> x \> x   \>  \funref{fun_getmaxyx}       \\
{\tt getmouse()}                 \>   \> x \>     \>         \\
{\tt getnwstr(...)}              \>   \> x \>     \>         \\          
{\tt getparyx(...)}              \>   \> x \> x   \>  \funref{fun_getparyx}       \\
{\tt getstr(str)}                \> x \> x \> x   \>  \funref{fun_getstr}       \\
{\tt getsyx(...)}                \>   \> x \> x   \>  \funref{fun_getsyx}       \\
{\tt gettmode()}                 \> x \> x \>     \>         \\
{\tt getwch(...)}                \>   \> x \>     \>         \\          
{\tt getwin(...)}                \>   \> x \>     \>         \\          
{\tt getwin(FILE *)}             \>   \> x \> x,n \>  \funref{fun_getwin}       \\
{\tt getwstr(...)}               \>   \> x \>     \>         \\          
{\tt getyx(...)}                 \> x \> x \> x   \>  \funref{fun_getyx}       \\
{\tt halfdelay(t)}               \>   \> x \> x   \>  \funref{fun_halfdelay}       \\
{\tt has\_colors()}              \>   \> x \> x   \>  \funref{fun_has_colors}       \\
{\tt has\_ic()}                  \>   \> x \> x,n \>  \funref{fun_has_ic}       \\
{\tt has\_il()}                  \>   \> x \> x,n \>  \funref{fun_has_il}       \\
{\tt hline(...)}                 \>   \> x \> x   \>  \funref{fun_hline}       \\
{\tt idcok(...)}                 \>   \> x \> x,n \>  \funref{fun_idcok}       \\
{\tt idlok(...)}                 \> x \> x \> x   \>  \funref{fun_idlok}       \\
{\tt immedok(...)}               \>   \> x \> x   \>  \funref{fun_immedok}       \\
{\tt inch()}                     \> x \> x \> x   \>  \funref{fun_inch}       \\
{\tt inchnstr(...)}              \>   \> x \> x,n \>  \funref{fun_inchnstr}       \\
{\tt inchstr(...)}               \>   \> x \> x,n \>  \funref{fun_inchstr}       \\
{\tt init\_color(...)}           \>   \> x \> x   \>  \funref{fun_init_color}       \\
{\tt init\_pair(...)}            \>   \> x \> x   \>  \funref{fun_init_pair}       \\
{\tt initscr()}                  \> x \> x \> x   \>  \funref{fun_initscr}       \\
{\tt innstr(...)}                \>   \> x \> x,n \>  \funref{fun_innstr}       \\
{\tt innwstr(...)}               \>   \> x \>     \>         \\          
{\tt insch(c)}                   \> x \> x \> x   \>  \funref{fun_insch}       \\
{\tt insdelln(n)}                \>   \> x \> x   \>  \funref{fun_insdelln}       \\
{\tt insertln()}                 \> x \> x \> x   \>  \funref{fun_insertln}       \\
{\tt insnstr(...)}               \>   \> x \> x   \>  \funref{fun_insnstr}       \\
{\tt insstr(str)}                \>   \> x \> x   \>  \funref{fun_insstr}       \\
{\tt instr(str)}                 \>   \> x \> x,n \>  \funref{fun_instr}       \\
{\tt inswch(...)}                \>   \> x \>     \>         \\          
{\tt inswstr(...)}               \>   \> x \>     \>         \\          
{\tt intrflush(...)}             \>   \> x \> x   \>  \funref{fun_intrflush}       \\
{\tt inwch(...)}                 \>   \> x \>     \>         \\          
{\tt inwchnstr(...)}             \>   \> x \>     \>         \\          
{\tt inwchstr(...)}              \>   \> x \>     \>         \\
{\tt inwchstr(...)}              \>   \> x \>     \>         \\          
{\tt inwstr(...)}                \>   \> x \>     \>         \\          
{\tt is\_linetouched(...)}       \>   \> x \> x   \>  \funref{fun_is_linetouched}       \\
{\tt is\_wintouched(win)}        \>   \> x \> x   \>  \funref{fun_is_wintouched}       \\
{\tt isendwin()}                 \>   \> x \> x   \>  \funref{fun_isendwin}       \\
{\tt keyname(c)}                 \>   \> x \> x   \>  \funref{fun_keyname}       \\
{\tt keypad(...)}                \>   \> x \> x   \>  \funref{fun_keypad}       \\
{\tt killchar()}                 \> x \> x \> x   \>  \funref{fun_killchar}       \\
{\tt leaveok(...)}               \> x \> x \> x   \>  \funref{fun_leaveok}       \\
{\tt longname()}                 \> x \> x \> x   \>  \funref{fun_longname}       \\
{\tt map\_button(long)}          \>   \> x \>     \>         \\
{\tt meta(...)}                  \>   \> x \> x   \>  \funref{fun_meta}       \\
{\tt mouse\_off(long)}           \>   \> x \>     \>         \\
{\tt mouse\_on(long)}            \>   \> x \>     \>         \\
{\tt mouse\_set(long)}           \>   \> x \>     \>         \\
{\tt move(...)}                  \> x \> x \> x   \>  \funref{fun_move}       \\
{\tt movenextch()}               \>   \> x \>     \>         \\       
{\tt moveprevch()}               \>   \> x \>     \>         \\       
{\tt mvaddbytes(...)}            \> x \>   \>     \>         \\
{\tt mvaddch(...)}               \> x \> x \> x   \>  \funref{fun_mvaddch}       \\
{\tt mvaddchnstr(...)}           \>   \> x \> x   \>  \funref{fun_mvaddchnstr}       \\
{\tt mvaddchstr(...)}            \>   \> x \> x   \>  \funref{fun_mvaddchstr}       \\
{\tt mvaddnstr(...)}             \>   \> x \> x   \>  \funref{fun_mvaddnstr}       \\
{\tt mvaddnwstr(...)}            \>   \> x \>     \>         \\          
{\tt mvaddstr(...)}              \> x \> x \> x   \>  \funref{fun_mvaddstr}       \\
{\tt mvaddwch(...)}              \>   \> x \>     \>         \\          
{\tt mvaddwchnstr(...)}          \>   \> x \>     \>         \\          
{\tt mvaddwchstr(...)}           \>   \> x \>     \>         \\          
{\tt mvaddwstr(...)}             \>   \> x \>     \>         \\          
{\tt mvcur(...)}                 \> x \> x \> x   \>  \funref{fun_mvcur}       \\
{\tt mvdelch(...)}               \> x \> x \> x   \>  \funref{fun_mvdelch}       \\
{\tt mvderwin(...)}              \>   \> x \> x,n \>  \funref{fun_mvderwin}       \\
{\tt mvgetch(...)}               \> x \> x \> x   \>  \funref{fun_mvgetch}       \\
{\tt mvgetnwstr(...)}            \>   \> x \>     \>         \\         
{\tt mvgetstr(...)}              \> x \> x \> x   \>  \funref{fun_mvgetstr}       \\
{\tt mvgetwch(...)}              \>   \> x \>     \>         \\          
{\tt mvgetwstr(...)}             \>   \> x \>     \>         \\          
{\tt mvhline(...)}               \>   \> x \>     \>         \\
{\tt mvinch(...)}                \> x \> x \> x   \>  \funref{fun_mvinch}       \\
{\tt mvinchnstr(...)}            \>   \> x \> x,n \>  \funref{fun_mvinchnstr}       \\
{\tt mvinchstr(...)}             \>   \> x \> x,n \>  \funref{fun_mvinchstr}       \\
{\tt mvinnstr(...)}              \>   \> x \> x,n \>  \funref{fun_mvinnstr}       \\
{\tt mvinnwstr(...)}             \>   \> x \>     \>         \\          
{\tt mvinsch(...)}               \> x \> x \> x   \>  \funref{fun_mvinsch}       \\
{\tt mvinsnstr(...)}             \>   \> x \> x   \>  \funref{fun_mvinsnstr}       \\
{\tt mvinsnwstr(...)}            \>   \> x \>     \>         \\          
{\tt mvinsstr(...)}              \>   \> x \> x   \>  \funref{fun_mvinsstr}       \\
{\tt mvinstr(...)}               \>   \> x \> x,n \>  \funref{fun_mvinstr}       \\
{\tt mvinswch(...)}              \>   \> x \>     \>         \\          
{\tt mvinswstr(...)}             \>   \> x \>     \>         \\          
{\tt mvinwch(...)}               \>   \> x \>     \>         \\          
{\tt mvinwchnstr(...)}           \>   \> x \>     \>         \\         
{\tt mvinwchstr(...)}            \>   \> x \>     \>         \\          
{\tt mvinwstr(...)}              \>   \> x \>     \>         \\          
{\tt mvprintw(...)}              \> x \> x \> x   \>  \funref{fun_mvprintw}       \\
{\tt mvscanw(...)}               \> x \> x \> x   \>  \funref{fun_mvscanw}       \\
{\tt mvvline(...)}               \>   \> x \>     \>         \\
{\tt mvwaddbytes(...)}           \> x \>   \>     \>         \\
{\tt mvwaddch(...)}              \> x \> x \> x   \>  \funref{fun_mvwaddch}       \\
{\tt mvwaddchnstr(...)}          \>   \> x \> x   \>  \funref{fun_mvwaddchnstr}       \\
{\tt mvwaddchstr(...)}           \>   \> x \> x   \>  \funref{fun_mvwaddchstr}       \\
{\tt mvwaddnstr(...)}            \>   \> x \> x   \>  \funref{fun_mvwaddnstr}       \\
{\tt mvwaddnwstr(...)}           \>   \> x \>     \>         \\          
{\tt mvwaddstr(...)}             \> x \> x \> x   \>  \funref{fun_mvwaddstr}       \\
{\tt mvwaddwch(...)}             \>   \> x \>     \>         \\          
{\tt mvwaddwchnstr(...)}         \>   \> x \>     \>         \\          
{\tt mvwaddwchstr(...)}          \>   \> x \>     \>         \\          
{\tt mvwaddwstr(...)}            \>   \> x \>     \>         \\          
{\tt mvwdelch(...)}              \> x \> x \> x   \>  \funref{fun_mvwdelch}       \\
{\tt mvwgetch(...)}              \> x \> x \> x   \>  \funref{fun_mvwgetch}       \\
{\tt mvwgetnwstr(...)}           \>   \> x \>     \>         \\          
{\tt mvwgetstr(...)}             \> x \> x \> x   \>  \funref{fun_mvwgetstr}       \\
{\tt mvwgetwch(...)}             \>   \> x \>     \>         \\          
{\tt mvwgetwstr(...)}            \>   \> x \>     \>         \\          
{\tt mvwhline(...)}              \>   \> x \>     \>         \\
{\tt mvwin(...)}                 \> x \> x \> x   \>  \funref{fun_mvwin}       \\
{\tt mvwinch(...)}               \> x \> x \> x   \>  \funref{fun_mvwinch}       \\
{\tt mvwinchnstr(...)}           \>   \> x \> x,n \>  \funref{fun_mvwinchnstr}       \\
{\tt mvwinchstr(...)}            \>   \> x \> x,n \>  \funref{fun_mvwinchstr}       \\
{\tt mvwinnstr(...)}             \>   \> x \> x,n \>  \funref{fun_mvwinnstr}       \\
{\tt mvwinnwstr(...)}            \>   \> x \>     \>         \\          
{\tt mvwinsch(...)}              \> x \> x \> x   \>  \funref{fun_mvwinsch}       \\
{\tt mvwinsnstr(...)}            \>   \> x \> x   \>  \funref{fun_mvwinsnstr}       \\
{\tt mvwinsstr(...)}             \>   \> x \> x   \>  \funref{fun_mvwinsstr}       \\
{\tt mvwinstr(...)}              \>   \> x \> x,n \>  \funref{fun_mvwinstr}       \\
{\tt mvwinswch(...)}             \>   \> x \>     \>         \\         
{\tt mvwinswstr(...)}            \>   \> x \>     \>         \\          
{\tt mvwinwch(...)}              \>   \> x \>     \>         \\          
{\tt mvwinwchnstr(...)}          \>   \> x \>     \>         \\          
{\tt mvwinwchstr(...)}           \>   \> x \>     \>         \\          
{\tt mvwinwstr(...)}             \>   \> x \>     \>         \\          
{\tt mvwprintw(...)}             \> x \> x \> x   \>  \funref{fun_mvwprintw}       \\
{\tt mvwscanw(...)}              \> x \> x \> x   \>  \funref{fun_mvwscanw}       \\
{\tt mvwvline(...)}              \>   \> x \>     \>         \\
{\tt napms(ms)}                  \>   \> x \> x   \>  \funref{fun_napms}       \\
{\tt newkey(...)}                \>   \> x \>     \>         \\
{\tt newpad(...)}                \>   \> x \> x   \>  \funref{fun_newpad}       \\  
{\tt newscreen(...)}             \>   \> x \>     \>         \\
{\tt newterm(...)}               \>   \> x \> x   \>  \funref{fun_newterm}       \\
{\tt newwin(...)}                \> x \> x \> x   \>  \funref{fun_newwin}       \\
{\tt nl()}                       \> x \> x \> x   \>  \funref{fun_nl}       \\
{\tt nocbreak()}                 \> x \> x \> x   \>  \funref{fun_nocbreak}       \\
{\tt nocrmode()}                 \> x \> x \> x   \>  \funref{fun_nocrmode}       \\
{\tt nodelay(...)}               \>   \> x \> x   \>  \funref{fun_nodelay}       \\
{\tt noecho()}                   \> x \> x \> x   \>  \funref{fun_noecho}       \\
{\tt nonl()}                     \> x \> x \> x   \>  \funref{fun_nonl}       \\
{\tt noqiflush()}                \>   \> x \> x,n \>  \funref{fun_noqiflush}       \\
{\tt noraw()}                    \> x \> x \> x   \>  \funref{fun_noraw}       \\
{\tt notimeout(...)}             \>   \> x \> x   \>  \funref{fun_notimeout}       \\
{\tt overlay(...)}               \> x \> x \> x   \>  \funref{fun_overlay}       \\
{\tt overwrite(...)}             \> x \> x \> x   \>  \funref{fun_overwrite}       \\
{\tt pair\_content(...)}         \>   \> x \> x   \>  \funref{fun_pair_content}       \\
{\tt pechochar(...)}             \>   \> x \> x   \>  \funref{fun_pechochar}       \\
{\tt pechowchar(...)}            \>   \> x \>     \>         \\          
{\tt pnoutrefresh(...)}          \>   \> x \> x   \>  \funref{fun_pnoutrefresh}       \\
{\tt prefresh(...)}              \>   \> x \> x   \>  \funref{fun_prefresh}       \\
{\tt printw(...)}                \> x \> x \> x   \>  \funref{fun_printw}       \\
{\tt putp(char *)}               \>   \> x \> x   \>  \funref{fun_putp}       \\
{\tt putwin(...)}                \>   \> x \> x,n \>  \funref{fun_putwin}       \\
{\tt qiflush()}                  \>   \> x \> x,n \>  \funref{fun_qiflush}       \\
{\tt raw()}                      \> x \> x \> x   \>  \funref{fun_raw}       \\
{\tt redrawwin(win)}             \>   \> x \> x   \>  \funref{fun_redrawwin}       \\
{\tt refresh()}                  \> x \> x \> x   \>  \funref{fun_refresh}       \\
{\tt request\_mouse\_pos()}      \>   \> x \>     \>         \\
{\tt reset\_prog\_mode()}        \>   \> x \> x   \>  \funref{fun_reset_prog_mode}       \\
{\tt reset\_shell\_mode()}       \>   \> x \> x   \>  \funref{fun_reset_shell_mode}       \\
{\tt resetty()}                  \> x \> x \> x   \>  \funref{fun_resetty}       \\
{\tt restartterm(...)}           \>   \> x \> x,n \>  \funref{fun_restartterm}       \\
{\tt ripoffline(...)}            \>   \> x \> x   \>  \funref{fun_ripoffline}       \\
{\tt savetty()}                  \> x \> x \> x   \>  \funref{fun_savetty}       \\
{\tt scanw(...)}                 \> x \> x \> x   \>  \funref{fun_scanw}       \\
{\tt scr\_dump(char *)}          \>   \> x \> x,n \>  \funref{fun_scr_dump}       \\
{\tt scr\_init(char *)}          \>   \> x \> x,n \>  \funref{fun_scr_init}       \\
{\tt scr\_restore(char *)}       \>   \> x \> x,n \>  \funref{fun_scr_restore}       \\
{\tt scr\_set(char *)}           \>   \> x \> x,n \>  \funref{fun_scr_set}       \\
{\tt scrl(n)}                    \>   \> x \> x   \>  \funref{fun_scrl}       \\
{\tt scroll(win)}                \> x \> x \> x   \>  \funref{fun_scroll}       \\
{\tt scrollok(...)}              \> x \> x \> x   \>  \funref{fun_scrollok}       \\
{\tt set\_curterm(...)}          \>   \> x \> x   \>  \funref{fun_set_curterm}       \\
{\tt set\_term(...)}             \>   \> x \> x   \>  \funref{fun_set_term}       \\
{\tt setcurscreen(SCREEN *)}     \>   \> x \>     \>         \\
{\tt setscrreg(...)}             \>   \> x \> x   \>  \funref{fun_setscrreg}       \\
{\tt setsyx(...)}                \>   \> x \> x   \>  \funref{fun_setsyx}       \\
{\tt setterm(char *)}            \> x \> x \> x   \>  \funref{fun_setterm}       \\
{\tt setupterm(...)}             \>   \> x \> x   \>  \funref{fun_setupterm}       \\
{\tt slk\_attroff(attr)}         \>   \> x \> x,n \>  \funref{fun_slk_attroff}       \\
{\tt slk\_attron(attr)}          \>   \> x \> x,n \>  \funref{fun_slk_attron}       \\
{\tt slk\_attrset(attr)}         \>   \> x \> x,n \>  \funref{fun_slk_attrset}       \\
{\tt slk\_clear()}               \>   \> x \> x   \>  \funref{fun_slk_clear}       \\
{\tt slk\_init(fmt)}             \>   \> x \> x   \>  \funref{fun_slk_init}       \\
{\tt slk\_label(labnum)}         \>   \> x \> x   \>  \funref{fun_slk_label}       \\
{\tt slk\_noutrefresh()}         \>   \> x \> x   \>  \funref{fun_slk_noutrefresh}       \\
{\tt slk\_refresh()}             \>   \> x \> x   \>  \funref{fun_slk_refresh}       \\
{\tt slk\_restore()}             \>   \> x \> x   \>  \funref{fun_slk_restore}       \\
{\tt slk\_set(...)}              \>   \> x \> x   \>  \funref{fun_slk_set}       \\
{\tt slk\_touch()}               \>   \> x \> x   \>  \funref{fun_slk_touch}       \\
{\tt standend()}                 \> x \> x \> x   \>  \funref{fun_standend}       \\
{\tt standout()}                 \> x \> x \> x   \>  \funref{fun_standout}       \\
{\tt start\_color()}             \>   \> x \> x   \>  \funref{fun_start_color}       \\
{\tt subpad(...)}                \>   \> x \> x   \>  \funref{fun_subpad}       \\
{\tt subwin(...)}                \> x \> x \> x   \>  \funref{fun_subwin}       \\
{\tt syncok(...)}                \>   \> x \> x,n \>  \funref{fun_syncok}       \\
{\tt termattrs()}                \>   \> x \> x,n \>  \funref{fun_termattrs}       \\
{\tt termname()}                 \>   \> x \> x,n \>  \funref{fun_termname}       \\
{\tt tgetent(...)}               \>   \> x \> x   \>  \funref{fun_nc_tgetent}       \\
{\tt tgetflag(char [2])}         \>   \> x \> x   \>  \funref{fun_nc_tgetflag}       \\
{\tt tgetnum(char [2])}          \>   \> x \> x   \>  \funref{fun_nc_tgetnum}       \\
{\tt tgetstr(...)}               \>   \> x \> x   \>  \funref{fun_nc_tgetstr}       \\
{\tt tgoto(...)}                 \>   \> x \> x   \>  \funref{fun_tgoto}       \\
{\tt tigetflag(...)}             \>   \> x \> x   \>  \funref{fun_tigetflag}       \\
{\tt tigetnum(...)}              \>   \> x \> x   \>  \funref{fun_tigetnum}       \\
{\tt tigetstr(...)}              \>   \> x \> x   \>  \funref{fun_tigetstr}       \\
{\tt timeout(t)}                 \>   \> x \> x   \>  \funref{fun_timeout}       \\
{\tt touchline(...)}             \> x \> x \> x   \>  \funref{fun_touchline}       \\
{\tt touchwin(win)}              \> x \> x \> x   \>  \funref{fun_touchwin}       \\
{\tt tparm(...)}                 \>   \> x \> x   \>  \funref{fun_tparm}       \\
{\tt tputs(...)}                 \>   \>   \> x   \>  \funref{fun_nc_tputs}       \\
{\tt traceoff()}                 \>   \> x \> x   \>  \funref{fun_traceoff}       \\
{\tt traceon()}                  \>   \> x \> x   \>  \funref{fun_traceon}       \\
{\tt typeahead(fd)}              \>   \> x \> x   \>  \funref{fun_typeahead}       \\
{\tt unctrl(chtype c)}           \>   \> x \> x   \>  \funref{fun_unctrl}       \\
{\tt ungetch(ch)}                \>   \> x \> x   \>  \funref{fun_ungetch}       \\
{\tt ungetwch(c)}                \>   \> x \>     \>         \\          
{\tt untouchwin(win)}            \>   \> x \> x   \>  \funref{fun_untouchwin}       \\
{\tt use\_env(bf)}               \>   \> x \> x   \>  \funref{fun_use_env}       \\
{\tt vidattr(...)}               \>   \> x \> x   \>  \funref{fun_vidattr}       \\
{\tt vidputs(...)}               \>   \> x \> x   \>  \funref{fun_vidputs}       \\
{\tt vidupdate(...)}             \>   \> x \>     \>         \\
{\tt vline(...)}                 \>   \> x \> x   \>  \funref{fun_vline}       \\
{\tt vwprintw(...)}              \>   \> x \> x   \>  \funref{fun_vwprintw}       \\
{\tt vwscanw(...)}               \>   \> x \> x   \>  \funref{fun_vwscanw}       \\
{\tt waddbytes(...)}             \> x \>   \>     \>         \\
{\tt waddch(...)}                \> x \> x \> x   \>  \funref{fun_waddch}       \\
{\tt waddchnstr(...)}            \>   \> x \> x   \>  \funref{fun_waddchnstr}       \\
{\tt waddchstr(...)}             \>   \> x \> x   \>  \funref{fun_waddchstr}       \\
{\tt waddnstr(...)}              \>   \> x \> x   \>  \funref{fun_waddnstr}       \\
{\tt waddnwstr(...)}             \>   \> x \>     \>         \\          
{\tt waddstr(...)}               \> x \> x \> x   \>  \funref{fun_waddstr}       \\
{\tt waddwch(...)}               \>   \> x \>     \>         \\          
{\tt waddwchnstr(...)}           \>   \> x \>     \>         \\          
{\tt waddwchstr(...)}            \>   \> x \>     \>         \\          
{\tt waddwstr(...)}              \>   \> x \>     \>         \\          
{\tt wadjcurspos(win)}           \>   \> x \>     \>         \\          
{\tt wattroff(...)}              \>   \> x \> x   \>  \funref{fun_wattroff}       \\
{\tt wattron(...)}               \>   \> x \> x   \>  \funref{fun_wattron}       \\
{\tt wattrset(...)}              \>   \> x \> x   \>  \funref{fun_wattrset}       \\
{\tt wbkgd(...)}                 \>   \> x \> x   \>  \funref{fun_wbkgd}       \\
{\tt wbkgdset(...)}              \>   \> x \> x   \>  \funref{fun_wbkgdset}       \\
{\tt wborder(...)}               \>   \> x \> x   \>  \funref{fun_wborder}       \\
{\tt wclear(win)}                \> x \> x \> x   \>  \funref{fun_wclear}       \\
{\tt wclrtobot(win)}             \> x \> x \> x   \>  \funref{fun_wclrtobot}       \\
{\tt wclrtoeol(win)}             \> x \> x \> x   \>  \funref{fun_wclrtoeol}       \\
{\tt wcursyncup(win)}            \>   \> x \> x,n \>  \funref{fun_wcursyncup}       \\
{\tt wdelch(win)}                \> x \> x \> x   \>  \funref{fun_wdelch}       \\
{\tt wdeleteln(win)}             \> x \> x \> x   \>  \funref{fun_wdeleteln}       \\
{\tt wechochar(...)}             \>   \> x \> x   \>  \funref{fun_wechochar}       \\
{\tt wechowchar(...)}            \>   \> x \>     \>         \\         
{\tt werase(win)}                \> x \> x \> x   \>  \funref{fun_werase}       \\
{\tt wgetch(win)}                \> x \> x \> x   \>  \funref{fun_wgetch}       \\
{\tt wgetnstr(...)}              \>   \> x \> x   \>  \funref{fun_wgetnstr}       \\
{\tt wgetnwstr(...)}             \>   \> x \>     \>         \\          
{\tt wgetstr(...)}               \> x \> x \> x   \>  \funref{fun_wgetstr}       \\
{\tt wgetwch(...)}               \>   \> x \>     \>         \\          
{\tt wgetwstr(...)}              \>   \> x \>     \>         \\          
{\tt whline()}                   \>   \> x \>     \>         \\
{\tt whline(...)}                \>   \> x \>     \>         \\
{\tt whline(...)}                \>   \> x \> x   \>  \funref{fun_whline}       \\
{\tt winch(win)}                 \> x \> x \> x   \>  \funref{fun_winch}       \\
{\tt winchnstr(...)}             \>   \> x \> x,n \>  \funref{fun_winchnstr}       \\
{\tt winchstr(...)}              \>   \> x \> x,n \>  \funref{fun_winchstr}       \\
{\tt winnstr(...)}               \>   \> x \> x,n \>  \funref{fun_winnstr}       \\
{\tt winnwstr(...)}              \>   \> x \>     \>         \\          
{\tt winsch(...)}                \> x \> x \> x   \>  \funref{fun_winsch}       \\
{\tt winsdelln(...)}             \> x \> x \> x   \>  \funref{fun_winsdelln}       \\
{\tt winsertln(win)}             \>   \> x \> x   \>  \funref{fun_winsertln}       \\
{\tt winsnstr(...)}              \>   \> x \> x   \>  \funref{fun_winsnstr}       \\
{\tt winsnwstr(...)}             \>   \> x \>     \>         \\          
{\tt winsstr(...)}               \>   \> x \> x   \>  \funref{fun_winsstr}       \\
{\tt winstr(...)}                \>   \> x \> x,n \>  \funref{fun_winstr}       \\
{\tt winswch(...)}               \>   \> x \>     \>         \\          
{\tt winswstr(...)}              \>   \> x \>     \>         \\         
{\tt winwch(...)}                \>   \> x \>     \>         \\          
{\tt winwchnstr(...)}            \>   \> x \>     \>         \\          
{\tt winwchstr(...)}             \>   \> x \>     \>         \\          
{\tt winwstr(...)}               \>   \> x \>     \>         \\          
{\tt wmouse\_position(...)}      \>   \> x \>     \>         \\
{\tt wmove(...)}                 \> x \> x \> x   \>  \funref{fun_wmove}       \\
{\tt wmovenextch(win)}           \>   \> x \>     \>         \\          
{\tt wmoveprevch(win)}           \>   \> x \>     \>         \\          
{\tt wnoutrefresh(win)}          \>   \> x \> x   \>  \funref{fun_wnoutrefresh}       \\
{\tt wprintw(...)}               \> x \> x \> x   \>  \funref{fun_wprintw}       \\
{\tt wredrawln(...)}             \>   \> x \> x   \>  \funref{fun_wredrawln}       \\
{\tt wrefresh(win)}              \> x \> x \> x   \>  \funref{fun_wrefresh}       \\
{\tt wscanw(...)}                \> x \> x \> x   \>  \funref{fun_wscanw}       \\
{\tt wscrl(...)}                 \>   \> x \> x   \>  \funref{fun_wscrl}       \\
{\tt wsetscrreg(...)}            \>   \> x \> x   \>  \funref{fun_wsetscrreg}       \\
{\tt wstandend(win)}             \> x \> x \> x   \>  \funref{fun_wstandend}       \\
{\tt wstandout(win)}             \> x \> x \> x   \>  \funref{fun_wstandout}       \\
{\tt wsyncdown(win)}             \>   \> x \> x,n \>  \funref{fun_wsyncdown}       \\
{\tt wsyncup(win)}               \>   \> x \> x,n \>  \funref{fun_wsyncup}       \\
{\tt wtimeout(...)}              \>   \> x \> x   \>  \funref{fun_wtimeout}       \\
{\tt wtouchln(...)}              \>   \> x \> x   \>  \funref{fun_wtouchln}       \\
{\tt wvline()}                   \>   \> x \>     \>         \\
{\tt wvline(...)}                \>   \> x \>     \>         \\
{\tt wvline(...)}                \>   \> x \> x   \>  \funref{fun_wvline}       \\
\end{tabbing}
\end{scriptsize}
\end{multicols}




Continuar\'a...

\endinput
%% LUISGH-1-END
