"curses" --- Manejo de terminales para pantallas de celdas de caracteres
************************************************************************

**Source code:** Lib/curses

======================================================================

El módulo "curses" provee una interfaz para la librería *curses*, el
estándar para el manejo avanzado de terminales portátiles.

Mientras que curses es más ampliamente usado en los ambientes Unix,
las versiones están disponibles para Windows, DOS, y posiblemente para
otros sistemas también. Esta extensión del módulo es diseñada para
coincidir con el API de ncurses, una librería de código abierto
almacenada en Linux y las variantes BSD de Unix.

Nota:

  Cuando la documentación menciona un *carácter*, esto puede ser
  especificado como un entero, una cadena Unicode de un carácter o una
  cadena de bytes de un byte.Cuando la documentación menciona una
  *cadena de caracteres*, esto puede ser especificado como una cadena
  Unicode o una cadena de bytes.

Ver también:

  Módulo "curses.ascii"
     Utilidades para trabajar con caracteres ASCII, independientemente
     de tu configuración local.

  Módulo "curses.panel"
     Una extensión de la pila de paneles que añade profundidad a las
     ventanas de curses.

  Módulo "curses.textpad"
     Widget de texto editable para apoyar curses  **Emacs**- como
     enlaces.

  Programación de curses con Python
     Material del tutorial usando curses con Python, por *Andrew
     Kuchling* y *Eric Raymond*.

  El directorio Tools/demo/ en el recurso de distribución de Python
  contiene algunos programas de ejemplo usando los enlaces de curses
  previstos en este módulo.


Funciones
=========

El módulo "curses" define la siguiente excepción:

exception curses.error

   Una excepción se lanza cuando una función de la librería curses
   retorna un error.

Nota:

  Cuando los argumentos *x* o *y* para una función o un método son
  opcionales, se predetermina la ubicación actual del cursor.  Cuando
  *attr* es opcional, por defecto es "A_NORMAL".

El módulo "curses" define las siguientes funciones:

curses.baudrate()

   Retorna la velocidad de salida de la terminal en bits por segundo.
   En emuladores de terminal de software esto tendrá un alto valor
   fijado. Incluido por razones históricas; en tiempos pasados, esto
   fue usado para escribir los ciclos de salida por retrasos de tiempo
   y ocasionalmente para cambiar interfaces dependiendo de la
   velocidad en la línea.

curses.beep()

   Emite un corto sonido de atención.

curses.can_change_color()

   Retorna "True" o "False", dependiendo ya sea que el programador
   puede cambiar los colores presentados por la terminal.

curses.cbreak()

   Entra al modo *cbreak*.  En el modo *cbreak* (a veces llamado modo
   "raro") del buffer de línea *tty* normal es apagado y los
   caracteres están disponibles para ser leídos uno por uno.  Sin
   embargo, a diferencia del modo raw, los caracteres especiales
   (interrumpir, salir, suspender y control de flujo) retiene sus
   efectos en el manejador *tty* y el programa de llamada.  Llamando
   primero "raw()" luego "cbreak()" dejando la terminal en modo
   *cbreak*.

curses.color_content(color_number)

   Retorna la intensidad de los componentes rojo, verde y azul (RGB)
   en el color *color_number*, que debe estar entre "0" y "COLORS-1".
   Retorna una tupla de 3, que contiene los valores R,G,B para el
   color dado, que estará entre "0" (sin componente) y "1000"
   (cantidad máxima de componente).

curses.color_pair(pair_number)

   Return the attribute value for displaying text in the specified
   color pair. Only the first 256 color pairs are supported. This
   attribute value can be combined with "A_STANDOUT", "A_REVERSE", and
   the other "A_*" attributes.  "pair_number()" is the counterpart to
   this function.

curses.curs_set(visibility)

   Configura el estado del cursor. *visibilidad* puede estar
   configurado para "0", "1" o "2", para invisible, normal o muy
   visible.  Si la terminal soporta la visibilidad requerida, retorna
   el estado del cursor previo; de otra manera ejecuta una excepción.
   En muchos terminales, el modo "visible" es un cursor subrayado y el
   modo "muy visible" es un cursor de bloque.

curses.def_prog_mode()

   Guardar el modo del terminal actual como el modo "program", el modo
   cuando el programa corriendo está usando curses. (Su contraparte es
   el modo "shell", para cuando el programa no está en curses.)
   Seguido de la llamada a "reset_prog_mode()" restaurará este modo.

curses.def_shell_mode()

   Guarde el modo de terminal actual como el modo "shell", el modo en
   el que el programa en ejecución no utiliza curses. (Su contraparte
   es el modo "program", cuando el programa está usando las
   capacidades de curses.)  Las llamadas subsecuentes a
   "reset_shell_mode()" restaurarán este modo.

curses.delay_output(ms)

   Inserte una pausa en milisegundo *ms* en la salida.

curses.doupdate()

   Actualiza la pantalla física. La librería curses mantiene dos
   estructuras de datos, uno representa el contenido de la pantalla
   física actual y una pantalla virtual representa el próximo estado
   deseado.  La base "doupdate()" actualiza la pantalla física para
   comparar la pantalla virtual.

   La pantalla virtual puede ser actualizada por una llamada
   "noutrefresh()" después de escribir las operaciones tales como
   "addstr()" ha sido ejecutada en una ventana. La llamada normal
   "refresh()" es simplemente "noutrefresh()" seguido por
   "doupdate()"; si tienes para actualizar múltiples ventanas, puedes
   aumentar el rendimiento y quizás reducir los parpadeos de la
   pantalla usando la llamada "noutrefresh()" en todas las ventanas,
   seguido por un simple "doupdate()".

curses.echo()

   Entrar en modo echo.  En modo echo, cada caracter de entrada es
   repercutido a la pantalla como este es introducido.

curses.endwin()

   Desinicializa la librería y retorne el terminal al estado normal.

curses.erasechar()

   Retorne el carácter borrado del usuario actual como un objeto de
   bytes de un byte. Bajo el sistema de operaciones Unix esta es una
   propiedad de el controlador tty de el programa curses, y no es
   configurado por la librería curses en sí misma.

curses.filter()

   La rutina "filter()", si es usada, debe ser llamada antes que
   "initscr()" sea llamada.  El efecto es que durante estas llamadas,
   "LINES" es configurada para "1"; las capacidades "clear", "cup",
   "cud", "cud1", "cuu1", "cuu", "vpa" son desactivadas; y la cadena
   "home" es configurada para el valor de "cr".  El efecto es que el
   cursor es confinado para la línea actual, y también las pantallas
   son actualizadas.  Este puede ser usado para habilitar la línea
   editando el carácter en un tiempo sin tocar el resto de las
   pantallas.

curses.flash()

   La pantalla Flash. Eso es, cambiar lo a video inverso y luego
   cambie lo de nuevo en un corto intervalo.  Algunas personas
   prefieren como 'campana visible' para la señal de atención audible
   producida por "beep()".

curses.flushinp()

   Vacíe todos los búferes de entrada.  Esto desecha cualquier
   mecanografiado que ha sido escrito por el usuario y no ha sido aún
   procesado por el programa.

curses.getmouse()

   Después de "getch()" retorna "KEY_MOUSE" para señalar un evento de
   mouse, se debe llamar a este método para recuperar el evento de
   mouse en cola, representado como una tupla de 5 "(id, x, y, z,
   bstate)". *id* es un valor de ID que se utiliza para distinguir
   varios dispositivos, y *x*, *y*, *z* son las coordenadas del
   evento. (*z* no se usa actualmente.) *bstate* es un valor entero
   cuyos bits se establecerán para indicar el tipo de evento, y será
   el OR bit a bit de una o más de las siguientes constantes, donde
   *n* es el botón número de 1 a 5: "BUTTONn_PRESSED",
   "BUTTONn_RELEASED", "BUTTONn_CLICKED", "BUTTONn_DOUBLE_CLICKED",
   "BUTTONn_TRIPLE_CLICKED", "BUTTON_SHIFT", "BUTTON_CTRL",
   "BUTTON_ALT".

   Distinto en la versión 3.10: Las constantes "BUTTON5_*" ahora están
   expuestas si son proporcionadas por la biblioteca curses
   subyacente.

curses.getsyx()

   Retorna las coordenadas actuales del cursor en la pantalla virtual
   como una tupla "(y, x)".  Si "leaveok" es actualmente "True"
   entonces retorna "(-1,-1)".

curses.getwin(file)

   Read window related data stored in the file by an earlier
   "window.putwin()" call. The routine then creates and initializes a
   new window using that data, returning the new window object.

curses.has_colors()

   Retorna "True" si el terminal puede desplegar colores, en caso
   contrario, retorna "False".

curses.has_extended_color_support()

   Retorna "True" si el módulo admite soporte de color extendido; de
   lo contrario retorna "False". El soporte de color extendido permite
   más de 256 pares de colores para terminales que admiten más de 16
   colores (por ejemplo, xterm-256color).

   El soporte de color extendido requiere ncurses versión 6.1 o
   posterior.

   Nuevo en la versión 3.10.

curses.has_ic()

   Retorna "True" si el terminal tiene la capacidad de insertar y
   eliminar caracteres.  Esta función es incluida por razones
   históricas solamente, ya que todos los emuladores de la terminal de
   software modernos tienen tales capacidades.

curses.has_il()

   Retorna "True" si la terminal tiene la capacidad de insertar y
   eliminar caracteres o pueden simularlos usando las regiones de
   desplazamiento.  Esta función es incluida por razones históricas
   solamente, como todos los emuladores de terminales de software
   modernos tienen tales capacidades.

curses.has_key(ch)

   Toma una clave valor *ch*, y retorna "True" si el tipo de terminal
   actual reconoce una clave con ese valor.

curses.halfdelay(tenths)

   Usado por el modo de medio retardo, el cual es similar al modo
   *cbreak* en que los caracteres escritos por el usuario están
   disponibles inmediatamente para el programa.  Sin embargo, después
   de bloquearlos por *tenths* décimas de segundos, se lanza una
   excepción si nada ha sido escrito. El valor de *tenths* debe ser un
   número entre "1" y "255".  Use "nocbreak()" para salir del modo de
   medio retardo.

curses.init_color(color_number, r, g, b)

   Change the definition of a color, taking the number of the color to
   be changed followed by three RGB values (for the amounts of red,
   green, and blue components).  The value of *color_number* must be
   between "0" and "COLORS - 1".  Each of *r*, *g*, *b*, must be a
   value between "0" and "1000".  When "init_color()" is used, all
   occurrences of that color on the screen immediately change to the
   new definition.  This function is a no-op on most terminals; it is
   active only if "can_change_color()" returns "True".

curses.init_pair(pair_number, fg, bg)

   Cambia la definición de un par de colores. Se necesitan tres
   argumentos: el número del par de colores que se va a cambiar, el
   número de color de primer plano y el número de color de fondo. El
   valor de *par_number* debe estar entre "1" y "COLOR_PAIRS-1" (el
   par de colores "0" está conectado a blanco sobre negro y no se
   puede cambiar). El valor de los argumentos *fg* y *bg* debe estar
   entre "0" y "COLORS-1" o, después de llamar a
   "use_default_colors()", "-1". Si el par de colores se inicializó
   previamente, la pantalla se actualiza y todas las apariciones de
   ese par de colores se cambian a la nueva definición.

curses.initscr()

   Inicializa la librería. Retorna un objeto window el cual representa
   a toda la pantalla.

   Nota:

     Si hay un error al abrir el terminal, la librería curses
     subyacente puede causar que el interprete salga.

curses.is_term_resized(nlines, ncols)

   Retorna "True" si "resize_term()" modificaría la estructura de la
   ventana, "False" en caso contrario.

curses.isendwin()

   Retorna "True" si "endwin()" ha sido llamado (eso es que la
   librería curses ha sido desinicializada).

curses.keyname(k)

   Retorna el nombre de la tecla enumerada *k* como un objeto de
   bytes.  El nombre de una tecla que genera un carácter ASCII
   imprimible es el carácter de la tecla.  El nombre de una
   combinación de teclas de control es un consistente objeto de bytes
   de dos bytes de un signo de intercalación ("b'^'") seguido por el
   correspondiente carácter ASCII imprimible. El nombre de una
   combinación de tecla *alt* (128-255) es un objeto de bytes
   consistente del prefijo "b'M-'" seguido por el nombre del
   correspondiente carácter ASCII.

curses.killchar()

   Retorna el carácter de eliminación de la línea actual del usuario
   como un objeto de bytes de un byte.  Bajo el sistema operativo Unix
   esta es una propiedad del controlador *tty* del programa *curses*,
   y no está configurado por la librería *curses* por sí mismo.

curses.longname()

   Retorna un objeto de bytes que contiene el campo de nombre largo
   *terminfo* que describe el terminal actual.  La longitud máxima de
   una descripción verbosa es 128 caracteres.  Esto es definido
   solamente después de la llamada a "initscr()".

curses.meta(flag)

   Si *flag* es "True", permite caracteres de 8 bits para ser
   introducidos.  Si *flag* es "False", permite solamente caracteres
   de 7 bits.

curses.mouseinterval(interval)

   Set the maximum time in milliseconds that can elapse between press
   and release events in order for them to be recognized as a click,
   and return the previous interval value.  The default value is 200
   milliseconds, or one fifth of a second.

curses.mousemask(mousemask)

   Configure los eventos del mouse para ser reportados, y retorna una
   tupla "(availmask, oldmask)". *availmask* indica cual de los
   eventos del ratón especificados pueden ser reportados; en caso de
   falla completa retorna "0".  *oldmask* es el valor previo de la
   máscara de evento del mouse de la ventana dada.  Si esta función
   nunca es llamada, los eventos del mouse nunca son reportados.

curses.napms(ms)

   Duerme durante *ms* milisegundos.

curses.newpad(nlines, ncols)

   Crea y retorna un apuntador para una nueva estructura de datos de
   *pad* con el número dado de líneas y columnas.  Retorna un *pad*
   como un objeto de ventana.

   Una almohadilla es como una ventana, excepto que no es restringida
   por el tamaño de la pantalla, y no está necesariamente asociada con
   una parte particular de la pantalla.  Las almohadillas pueden ser
   usadas cuando un ventana grande es necesitada, y solamente una
   parte de la ventana estará en la pantalla de una sola vez.
   Actualizaciones automáticas de almohadillas (tales desde el
   desplazamiento o haciendo eco de la entrada) no ocurre.  Los
   métodos "refresh()" y "noutrefresh()" de una almohadilla requiere 6
   argumentos para especificar la parte de la almohadilla a ser
   mostrada y la locación en la ventana que se utilizará para la
   visualización.  Los argumentos son *pminrow*, *pmincol*, *sminrow*,
   *smincol*, *smaxrow*, *smaxcol*; el argumento *p* se refiere a la
   esquina superior izquierda de la región de la almohadilla a ser
   mostrada y el argumento *s* define una caja de recorte en la
   pantalla con la cual la región de la almohadilla será mostrada.

curses.newwin(nlines, ncols)
curses.newwin(nlines, ncols, begin_y, begin_x)

   Retorna una nueva window, cuya esquina superior izquierda esta en
   "(begin_y, begin_x)", y cuyo alto/ancho es *nlines*/*ncols*.

   Por defecto, la ventana extenderá desde la posición especificada
   para la esquina inferior derecha de la pantalla.

curses.nl()

   Ingrese al modo de línea nueva.  Este modo pone la tecla de retorno
   en una nueva línea en la entrada, y traduce la nueva línea en
   retorno y avance de línea en la salida. El modo de nueva línea está
   inicialmente encendida.

curses.nocbreak()

   Salir del modo *cbreak*.  Retorne al modo normal "cooked" con la
   línea del búfer.

curses.noecho()

   Salir del modo echo. El eco de los caracteres de entrada está
   desactivado.

curses.nonl()

   Dejar el modo de nueva línea. Desactiva la traducción de retorno en
   una nueva línea en la entrada, y desactiva la traducción a bajo
   nivel de una nueva línea en nueva línea/retorno en la salida (pero
   esto no cambia el comportamiento de "addch('\n')", el cual siempre
   es el equivalente de retornar y avanzar la línea en la pantalla
   virtual). Con las traducciones apagadas, *curses* puede aumentar
   algunas veces la velocidad del movimiento vertical un poco;
   también, estará disponible para detectar la tecla de retorno en la
   entrada.

curses.noqiflush()

   Cuando la rutina "noqiflush()" es usada, descarga normal de colas
   de entrada y salida asociadas con el "INTR", los caracteres "QUIT"
   and "SUSP" no serán hechos.  Puedes querer llamar "noqiflush()" en
   un manejador de señales si quieres que la salida continúe como si
   la interrupción no hubiera ocurrido después de que el manejador
   exista.

curses.noraw()

   Salir del modo raw. Retorna al modo normal "cooked" con la línea
   del búfer.

curses.pair_content(pair_number)

   Retorna una tupla "(fg, bg)" conteniendo los colores del par de
   color solicitado. El valor de *pair_number* debe ser entre "0" y
   "COLOR_PAIRS-1".

curses.pair_number(attr)

   Retorna el numero del conjunto de pares de colores para el valor
   del atributo *attr*. "color_pair()" es la contraparte de esta
   función.

curses.putp(str)

   Equivalente a "tputs(str, 1, putchar)"; emite el valor de una
   capacidad especificada *terminfo* para el terminal actual. Nota que
   la salida de "putp()" siempre va a la salida estándar.

curses.qiflush([flag])

   Si *flag* es "False", el efecto es el mismo como llamar
   "noqiflush()".  Si *flag* es "True",  o el argumento no es
   proveído, la cola será nivelada cuando estos caracteres de control
   son leídos.

curses.raw()

   Entrar al modo crudo.  En el modo crudo, el almacenamiento en búfer
   de la línea normal y procesamiento de las teclas de interrupción,
   salida, suspensión y control de flujo son apagadas; los caracteres
   son presentados a la función de entrada de *curses* una por una.

curses.reset_prog_mode()

   Restaura la terminal para el modo "program", anteriormente guardado
   por "def_prog_mode()".

curses.reset_shell_mode()

   Restablece el terminal al modo "shell" como lo guardó previamente
   "def_shell_mode()".

curses.resetty()

   Restablece el estado del modo del terminal para lo que esto fue en
   el último llamado a "savetty()".

curses.resize_term(nlines, ncols)

   La función *backend* usada por "resizeterm()", caracteriza más de
   el trabajo; cuando se redimensiona la ventana, "resize_term()" los
   rellenos blancos de las áreas que son extendidas.  La aplicación de
   llamada llenaría en estas áreas con datos apropiados.  La función
   "resize_term()" intenta redimensionar todas las ventanas.  Sin
   embargo, debido a la convención de llamadas del las almohadillas,
   esto no es posible para redimensionar estos sin interacciones
   adicionales con la aplicación.

curses.resizeterm(nlines, ncols)

   Ajusta el tamaño al estándar y la ventana actual para las
   dimensiones especificadas, y ajusta otros datos contables usados
   por la librería *curses* que registra las dimensiones de la ventana
   (en particular el manejador SIGWINCH ).

curses.savetty()

   Guarda el estado actual del modo del terminal en un búfer, usable
   por "resetty()".

curses.get_escdelay()

   Recupera el valor establecido por "set_escdelay()".

   Nuevo en la versión 3.9.

curses.set_escdelay(ms)

   Establece el número de milisegundos de espera después de leer un
   carácter de escape, para distinguir entre un carácter de escape
   individual ingresado en el teclado de las secuencias de escape
   enviadas por el cursor y las teclas de función.

   Nuevo en la versión 3.9.

curses.get_tabsize()

   Recupera el valor establecido por "set_tabsize()".

   Nuevo en la versión 3.9.

curses.set_tabsize(size)

   Establece el número de columnas utilizadas por la biblioteca de
   curses al convertir un carácter de tabulación en espacios, ya que
   agrega la tabulación a una ventana.

   Nuevo en la versión 3.9.

curses.setsyx(y, x)

   Fija el cursor de la pantalla virtual para *y*, *x*.  Si *y* y *x*
   son ambos "-1", entonces "leaveok" es configurado "True".

curses.setupterm(term=None, fd=-1)

   Inicializa la terminal.  *term* es una cadena de caracteres dando
   el nombre de la terminal, o "None"; si es omitido o "None", el
   valor de la variable de entorno "TERM" será usada.  *fd* es el
   archivo descriptor al cual alguna secuencia de inicialización será
   enviada; si no es suministrada o "-1", el archivo descriptor para
   "sys.stdout" será usado.

curses.start_color()

   Debe ser llamado si el programador quiere usar colores, y antes de
   que cualquier otra rutina de manipulación de colores sea llamada.
   Esta es una buena práctica para llamar esta rutina inmediatamente
   después de "initscr()".

   "start_color()" inicializa ocho colores básicos (negro, rojo,
   verde, amarillo, azul, magenta, cian, y blanco), y dos variables
   globales en el módulo "curses", "COLORS" y "COLOR_PAIRS", contiene
   el número máximo de colores y los pares de colores que la terminal
   puede soportar.  Esto también restaura los colores en la terminal
   para los valores que ellos tienen cuando la terminal fue solo
   activada.

curses.termattrs()

   Retorna un *OR* lógico de todos los atributos del video soportados
   por el terminal.  Esta información es útil cuando un programa
   *curses* necesita completar el control sobre la apariencia de la
   pantalla.

curses.termname()

   Retorna el valor de la variable de entorno "TERM", como un objeto
   de bytes, trucado para 14 caracteres.

curses.tigetflag(capname)

   Retorna el valor de la capacidad booleana correspondiente al nombre
   de la capacidad *terminfo* *capname* como un número entero.
   Retorna el valor "-1" si *capname* no es una capacidad booleana, o
   "0" si es cancelada o ausente desde la descripción de la terminal.

curses.tigetnum(capname)

   Retorna el valor de la capacidad numérica correspondiente al nombre
   de la capacidad *terminfo* *capname* como un entero.  Regresa el
   valor "-2" si *capname* no es una capacidad numérica, o "-1" si
   esta es cancelada o ausente desde la descripción del terminal.

curses.tigetstr(capname)

   Retorna el valor de la capacidad de la cadena de caracteres
   correspondiente al nombre de la capacidad *terminfo* *capname* como
   un objeto de bytes.  Retorna "None" si *capname* no es una
   "capacidad de cadena de caracteres" de *terminfo*, o es cancelada o
   ausente desde la descripción de la terminal.

curses.tparm(str[, ...])

   Instancia del objeto de bytes *str* con los parámetros
   suministrados, dónde *str* sería un cadena de caracteres
   parametrizada obtenida desde la base de datos de *terminfo*.  E.g.
   "tparm(tigetstr("cup"), 5, 3)" podría resultar en "b'\033[6;4H'",
   el resultado exacto depende del tipo de terminal.

curses.typeahead(fd)

   Especifica que el descriptor de archivo *fd* es usado para la
   verificación anticipada. Si *fd* es "-1", entonces no se realiza
   ninguna verificación anticipada.

   La librería *curses* hace "la optimización del rompimiento de
   línea" por la búsqueda para mecanografiar periódicamente mientras
   se actualiza la pantalla.  Si la entrada es encontrada, y viene
   desde un *tty*, la actualización actual es pospuesta hasta que se
   vuelva a llamar la actualización, permitiendo la respuesta más
   rápida para comandos escritos en avance.  Esta función permite
   especificar un archivo diferente al descriptor para la verificación
   anticipada.

curses.unctrl(ch)

   Regresa un objeto de bytes el cual es una representación imprimible
   del carácter *ch*.  Los caracteres de control son representados
   como un símbolo de intercalación seguido del carácter, por ejemplo
   como "b'^C'".  La impresión de caracteres son dejados como están.

curses.ungetch(ch)

   Presiona *ch* para que el siguiente "getch()" lo retorne.

   Nota:

     Solamente un *ch* puede ser colocado antes "getch()" es llamada.

curses.update_lines_cols()

   Update the "LINES" and "COLS" module variables. Useful for
   detecting manual screen resize.

   Nuevo en la versión 3.5.

curses.unget_wch(ch)

   Presiona *ch* para que el siguiente "get_wch()" lo retorne.

   Nota:

     Solamente un *ch* puede ser presionado antes "get_wch()" es
     llamada.

   Nuevo en la versión 3.3.

curses.ungetmouse(id, x, y, z, bstate)

   Coloca un evento "KEY_MOUSE" en la cola de entrada, asociando el
   estado de los datos dados con esto.

curses.use_env(flag)

   Si es usado, esta función sería llamada antes de "initscr()" o
   *newterm* son llamados.  Cuando *flag* es "False", los valores de
   líneas y columnas especificadas en la base de datos *terminfo* será
   usado, incluso si las variables de entorno "LINES" y "COLUMNS"
   (usadas por defecto) son configuradas, o si *curses* está corriendo
   en una ventana (en cuyo caso el comportamiento por defecto sería
   usar el tamaño de ventana si "LINES" y "COLUMNS" no están
   configuradas).

curses.use_default_colors()

   Permite usar valores por defecto para los colores en terminales
   apoyando esta característica.  Use esto para apoyar la
   transparencia en tu aplicación.  El color por defecto es asignada
   para el número de color "-1".  Después de llamar esta función,
   inicializa "init_pair(x, curses.COLOR_RED, -1)", por ejemplo, los
   pares de color *x* a un primer plano de color rojo en el fondo por
   defecto.

curses.wrapper(func, /, *args, **kwargs)

   Inicializa *curses* y llama a otro objeto invocable, *func*, el
   cual debería ser el resto de tu aplicación que usa *curses*.  Si la
   aplicación lanza una excepción, esta función restaurará la terminal
   para un estado sano antes de re-lanzar la excepción y generar un
   una pista.  El objeto invocable *func* es entonces pasado a la
   ventana principal 'stdscr' como su primer argumento, seguido por
   algún otro argumento pasado a "wrapper()".  Antes de llamar a
   *func*, "wrapper()" habilita el modo *cbreak*, desactiva echo,
   permite el teclado del terminal, e inicializa los colores si la
   terminal tiene soporte de color.  En salida (ya sea normal o por
   excepción) esto restaura el modo *cooked*, habilita el echo, y
   desactiva el teclado del terminal.


Objetos de ventana
==================

Los objetos ventana, retornados por "initscr()" y "newwin()"
anteriores, tienen los siguientes métodos y atributos:

window.addch(ch[, attr])
window.addch(y, x, ch[, attr])

   Pinta el carácter *ch* en "(y, x)" con atributos *attr*,
   sobrescribiendo cualquier carácter pintado previamente en esa
   ubicación. De forma predeterminada, la posición y los atributos del
   carácter son la configuración actual del objeto ventana.

   Nota:

     Escribiendo afuera de la ventana, sub-ventana, o *pad* genera un
     "curses.error".  Intentando escribir en la esquina inferior
     derecha de una ventana, sub-ventana, o *pad* causará una
     excepción a ser generada después de que el carácter es pintado.

window.addnstr(str, n[, attr])
window.addnstr(y, x, str, n[, attr])

   Pintar como máximo *n* caracteres de la cadena de texto *str* en
   "(y,x)" con atributos *attr*, sobrescribiendo algo previamente en
   la pantalla.

window.addstr(str[, attr])
window.addstr(y, x, str[, attr])

   Dibuja la cadena de caracteres *str* en "(y,x)" con atributos
   *attr*, sobrescribiendo cualquier cosa previamente en la pantalla.

   Nota:

     * Escribiendo afuera de la ventana, sub-ventana, o *pad* genera
       un "curses.error".  Intentando escribir en la esquina inferior
       derecha de una ventana, sub-ventana, o *pad* causará una
       excepción a ser generada después de que la cadena de caracteres
       es pintada.

     * Un bug en *ncurses*, el *backend* para este módulo de Python,
       puede causar *SegFaults* cuando re-dimensionan las ventanas.
       Esto es reparado en ncurses-6.1-20190511.  Si tu estás atascado
       con un *ncurses* anterior, puedes evitar desencadenar este si
       no llamas "addstr()"  con un *str* que tiene embebido nuevas
       líneas.  En su lugar, llama "addstr()" separadamente por cada
       línea.

window.attroff(attr)

   Remueve el atributo *attr* desde el conjunto "background" aplicado
   a todos los escritos para la ventana actual.

window.attron(attr)

   Añade el atributo *attr* del conjunto del "background" aplicado
   para todas las escrituras de la ventana actual.

window.attrset(attr)

   Establezca el conjunto de atributos "background para *attr*.  Este
   conjunto es inicialmente "0" (sin atributos).

window.bkgd(ch[, attr])

   Configura la propiedad de fondo de la ventana para el carácter
   *ch*, con atributos *atte*.  El cambio es entonces aplicado para la
   posición de cada carácter en esa ventana:

   * El atributo de cada carácter en la ventana es cambiado por el
     nuevo atributo de fondo.

   * Dónde quiera que el carácter del fondo anterior aparezca, es
     cambiado al nuevo carácter de fondo.

window.bkgdset(ch[, attr])

   Configura el fondo de la ventana.  Un fondo de ventana consiste de
   un carácter y cualquier combinación de atributos.  La parte del
   atributo del fondo es combinado (OR' ed) con todos los caracteres
   que no son blancos escritos en la ventana.  Tanto las partes del
   carácter y del atributo del fondo son combinados con los caracteres
   en blanco.  El fondo se convierte en una propiedad del carácter y
   se mueve con el carácter a través de cualquier operación de
   desplazamiento e inserción/eliminación de línea/carácter.

window.border([ls[, rs[, ts[, bs[, tl[, tr[, bl[, br]]]]]]]])

   Dibuja un borde alrededor de las orillas de la ventana.  Cada
   parámetro especifica el carácter a usar para una parte específica
   del borde; ve la tabla abajo para más detalles.

   Nota:

     Un valor "0" para cualquier parámetro causará el carácter por
     defecto a ser usado para ese parámetro. parámetros de palabras
     clave pueden *no* ser usados. Los valores predeterminados son
     listados en esta tabla:

   +-------------+-----------------------+-------------------------+
   | Parámetro   | Descripción           | Valor por defecto       |
   |=============|=======================|=========================|
   | *ls*        | Lado izquierdo        | "ACS_VLINE"             |
   +-------------+-----------------------+-------------------------+
   | *rs*        | Lado derecho          | "ACS_VLINE"             |
   +-------------+-----------------------+-------------------------+
   | *ts*        | Arriba                | "ACS_HLINE"             |
   +-------------+-----------------------+-------------------------+
   | *bs*        | Abajo                 | "ACS_HLINE"             |
   +-------------+-----------------------+-------------------------+
   | *tl*        | Esquina superior      | "ACS_ULCORNER"          |
   |             | izquierda             |                         |
   +-------------+-----------------------+-------------------------+
   | *tr*        | Esquina superior      | "ACS_URCORNER"          |
   |             | derecha               |                         |
   +-------------+-----------------------+-------------------------+
   | *bl*        | Esquina inferior      | "ACS_LLCORNER"          |
   |             | izquierda             |                         |
   +-------------+-----------------------+-------------------------+
   | *br*        | Esquina inferior      | "ACS_LRCORNER"          |
   |             | derecha               |                         |
   +-------------+-----------------------+-------------------------+

window.box([vertch, horch])

   Similar a "border()", pero ambos *ls y *rs* son *vertch* y ambos
   *ts* y *bs* son *horch*.  Los caracteres de esquina predeterminados
   son siempre usados por esta función.

window.chgat(attr)
window.chgat(num, attr)
window.chgat(y, x, attr)
window.chgat(y, x, num, attr)

   Configura los atributos de *num* de caracteres en la posición del
   cursor, o una posición "(y, x)" si es suministrado.  Si *num* no es
   dado o es "-1", el atributo será configurado en todos los
   caracteres para el final de la línea.  Esta función mueve el cursor
   a la posición "(y, x)" si es suministrado.  La línea cambiada será
   tocada usando el método "touchline()" tal que el contenido será
   vuelto a mostrar por la actualización de la siguiente ventana.

window.clear()

   Semejante a "erase()", pero también causa que toda la ventana sea
   repintada sobre la siguiente llamada para "refresh()".

window.clearok(flag)

   Si *flag* es "True", la siguiente llamada para "refresh()" limpiará
   la ventana completamente.

window.clrtobot()

   Borrar desde el cursor hasta el final de la ventana: todas las
   líneas bajo el cursor son eliminadas, y entonces el equivalente de
   "clrtoeol()" es realizado.

window.clrtoeol()

   Borrar desde el cursor hasta el final de la línea.

window.cursyncup()

   Actualice la posición actual del cursor de todos los ancestros de
   la ventana para reflejar la posición actual del cursor de la
   ventana.

window.delch([y, x])

   Borrar cualquier carácter en "(y,x)".

window.deleteln()

   Borra la línea bajo el cursor.  Todas las líneas siguientes son
   movidas una línea hacía arriba.

window.derwin(begin_y, begin_x)
window.derwin(nlines, ncols, begin_y, begin_x)

   Una abreviación para "ventana derivada", "derwin()" es el mismo
   cómo llamar "subwin()", excepto que *begin_y* y *begin_x* son
   relativos al origen de la ventana, más bien relativo a la pantalla
   completa.  Retorna un objeto ventana para la ventana derivada.

window.echochar(ch[, attr])

   Añada el carácter *ch* con atributo *attr*, e inmediatamente llame
   a "refresh()" en la ventana.

window.enclose(y, x)

   Pruebe si el par dado de las coordenadas de celda del carácter
   relativas de la ventana son encerrados por la ventana dada,
   retornando "True" o "False". Esto es útil para determinar que
   subconjunto de las ventanas de pantalla encierran la locación de un
   evento del mouse.

   Distinto en la versión 3.10: Anteriormente retornaba "1" o "0" en
   lugar de "True" o "False".

window.encoding

   Encoding used to encode method arguments (Unicode strings and
   characters). The encoding attribute is inherited from the parent
   window when a subwindow is created, for example with
   "window.subwin()". By default, current locale encoding is used (see
   "locale.getencoding()").

   Nuevo en la versión 3.3.

window.erase()

   Limpiar la ventana.

window.getbegyx()

   Retorna una tupla "(y,x)" de coordenadas de la esquina superior
   izquierda.

window.getbkgd()

   Retorna el par carácter/atributo dada la ventana actual.

window.getch([y, x])

   Obtener un carácter.  Nota que el entero retornado *no* tiene que
   estar en el rango ASCII: teclas de función, claves de teclado y los
   demás son representados por números mayores que 255.  En el modo
   sin demora, retorna "-1" si no hay entrada, en caso contrario
   espere hasta que una tecla es presionada.

window.get_wch([y, x])

   Obtener un carácter amplio.  Retorna un carácter para la mayoría de
   las teclas, o un entero para las teclas de función, teclas del
   teclado, y otras teclas especiales.  En modo de no retorna, genera
   una excepción si no hay entrada.

   Nuevo en la versión 3.3.

window.getkey([y, x])

   Obtener un carácter, retornando una cadena de caracteres en lugar
   de un entero, como "getch()" lo hace.  Las teclas de función,
   teclas del teclado y otras teclas especiales retornan una cadena
   *multibyte* conteniendo el nombre de la tecla.  En modo de no
   retardo, genera una excepción si no hay entrada.

window.getmaxyx()

   Retorna una tupla "(y,x)" de el alto y ancho de la ventana.

window.getparyx()

   Retorne las coordenadas iniciales de esta ventana relativa para su
   ventana padre como una tupla "(y, x)".  Retorna "(-1, -1)" si esta
   ventana no tiene padre.

window.getstr()
window.getstr(n)
window.getstr(y, x)
window.getstr(y, x, n)

   Lee un objeto de bytes desde el usuario, con capacidad de edición
   de línea primitiva.

window.getyx()

   Retorna una tupla "(y, x)" de la posición actual del cursor
   relativa para la esquina superior izquierda de la ventana.

window.hline(ch, n)
window.hline(y, x, ch, n)

   Muestra una línea horizontal iniciando en "(y, x)" con longitud *n*
   consistente de el carácter *ch*.

window.idcok(flag)

   Si *flag* es "False", *curses* ya no considera el uso de la función
   de insertar/eliminar caracteres de hardware del terminal; si *flag*
   "True", el uso de inserción y borrado  de caracteres está
   habilitado.  Cuando *curses* es inicializado primero, el uso de
   caracteres de inserción / borrado está habilitado por defecto.

window.idlok(flag)

   Si *flag* es "True", "curses" tratará y usará las funciones de la
   línea de edición de hardware.  En caso contrario, la línea
   inserción/borrado están deshabilitadas.

window.immedok(flag)

   Si *flag* es "True", cualquier cambio en la imagen de la ventana
   automáticamente causará que la ventana sea refrescada; ya no tienes
   que llamar a "refresh()" por ti mismo.  Sin embargo, esto puede
   degradar el rendimiento considerablemente, debido a las
   repeticiones de llamada a *wrefresh*.  Esta opción está
   deshabilitada por defecto.

window.inch([y, x])

   Retorna el carácter en la posición dada en la ventana.  Los 8bits
   inferiores son los caracteres propiamente dichos, y los bits
   superiores son los atributos.

window.insch(ch[, attr])
window.insch(y, x, ch[, attr])

   Pinta el carácter *ch* en "(y, x)" con atributos *attr*, moviendo
   la línea desde la posición *x* a la derecha un carácter.

window.insdelln(nlines)

   Inserta *nlines* líneas en la ventana especificada arriba de la
   línea actual.  Las *nlines* líneas de fondo se pierden.  Para
   *nlines* negativos, elimine *nlines* líneas comenzando con la que
   está debajo del cursor, y mueve las restantes hacia arriba. Se
   borran las *nlines* líneas inferiores.  La posición del cursor
   actual se mantiene igual.

window.insertln()

   Inserte una línea en blanco bajo el cursos.  Las líneas siguientes
   se moverán una línea hacía abajo.

window.insnstr(str, n[, attr])
window.insnstr(y, x, str, n[, attr])

   Inserte una cadena de caracteres (tantos caracteres quepan en la
   línea) antes los caracteres bajo el cursor, sobre los *n*
   caracteres.  Si *n* es cero o negativo, la cadena entera es
   insertada.  Todos los caracteres a la derecha de el cursor son
   desplazados a la derecha, perdiéndose los caracteres de la derecha
   en la línea.  La posición del cursor no cambia (después de mover a
   *y*, *x*, si es especificado).

window.insstr(str[, attr])
window.insstr(y, x, str[, attr])

   Inserte una cadena de caracteres ( tantos caracteres encajen en la
   línea) antes los caracteres bajo el cursor.  Todos los caracteres a
   la derecha de el cursor son desplazados a la derecha, perdiéndose
   los caracteres de la derecha en línea.

window.instr([n])
window.instr(y, x[, n])

   Regresa un objeto de bytes de caracteres, extraídos desde la
   ventana comenzando en la posición actual del cursor, o en *y*, *x*
   si es especificado.  Los atributos son despojados desde los
   caracteres.  Si *n* es especificado, "instr()" retorna una cadena
   de caracteres como máximo de *n* caracteres (exclusivo de la NULL
   final).

window.is_linetouched(line)

   Retorna "True" si la línea especificada fue modificada desde la
   última llamada a "refresh()"; de otra manera retorna "False".
   Genera una excepción "curses.error" si *line* no es válida para la
   ventana dada.

window.is_wintouched()

   Retorna "True" si la ventana especificada fue modificada desde la
   última llamada para "refresh()"; en caso contrario, retorna
   "False".

window.keypad(flag)

   Si *flag* es "True", evita las secuencias generadas por algunas
   teclas (teclado, teclas de función) será interpretadas por
   "curses".  Si *flag* es "False", evita las secuencias que serán
   dejadas como está en la corriente de entrada.

window.leaveok(flag)

   Si *flag* es "True", el cursor es dejado donde está en la
   actualización, por ejemplo estando en "cursor position." Esto
   reduce el movimiento del cursor siempre que sea posible.  Si es
   posible, el cursor se hará invisible.

   Si *flag* es "False", el cursor siempre estará en "cursor position"
   después de una actualización.

window.move(new_y, new_x)

   Mueve el cursor a "(new_y, new_x)".

window.mvderwin(y, x)

   Mueve la ventana adentro de su ventana padre.  Los parámetros
   relativos a la pantalla de la ventana no son cambiados.  Esta
   rutina es usada para mostrar diferentes partes de la ventana padre
   en la misma posición física en la pantalla.

window.mvwin(new_y, new_x)

   Mueve la ventana a su esquina superior izquierda que está en
   "(new_y,new_x)".

window.nodelay(flag)

   Si *flag* es "True", "getch()" no será bloqueada.

window.notimeout(flag)

   Si *flag* es "True", las secuencias de escape no serán agotadas.

   Si *flag* es "False", después de pocos milisegundos, una secuencia
   de escape no será interpretada, y será dejada en el flujo de
   entrada como está.

window.noutrefresh()

   Marque para actualizar pero espere.  Esta función actualiza la
   estructura de datos representando el estado deseado de la ventana,
   pero no fuerza una actualización en la pantalla física.  Para
   realizar eso, llame "doupdate()".

window.overlay(destwin[, sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol])

   Cubre la ventana en la parte superior de *destwin*.  La ventana no
   necesita ser del mismo tamaño, solamente se solapa la región
   copiada.  Esta copia no es destructiva, lo que significa que el
   carácter de fondo actual no sobre-escribe el contenido viejo de
   *destwin*.

   Para obtener el control de grano fino sobre la región copiada, la
   segunda forma de "overlay()" puede ser usada.  *sminrow* y
   *smincol* son las coordenadas superior izquierda de la ventana de
   origen, y las otras variables marcan un rectángulo en la ventana
   destino.

window.overwrite(destwin[, sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol])

   Sobre-escribe la ventana en la parte superior de *destwin*.  La
   ventana no necesita ser del mismo tamaño, en cuyo caso solamente se
   sobrepone la región que es copiada.  Esta copia es destructiva, lo
   cual significa que el carácter de fondo actual sobre-escribe el
   contenido viejo de *destwin*.

   Para obtener el control de grano fino sobre la región copiada, la
   segunda forma de "overwrite()" puede ser usada.  *sminrow* y
   *smincol* son las coordenadas superior izquierda de la ventana
   origen, las otras variables marcan un rectángulo en la ventana de
   destino.

window.putwin(file)

   Escribe todos los datos asociados con la ventana en el objeto de
   archivo proveído.  Esta información puede estar después recuperada
   usando la función "getwin()".

window.redrawln(beg, num)

   Indica que el *num* de líneas de la pantalla, empiezan en la línea
   *beg*, son corruptos y deberían ser completamente redibujado en la
   siguiente llamada "refresh()".

window.redrawwin()

   Toca la ventana completa, causando que se vuelva a dibujar
   completamente en la siguiente llamada "refresh()" .

window.refresh([pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol])

   Actualiza la pantalla inmediatamente (sincronice la pantalla actual
   con los métodos previos de dibujar/borrar).

   Los 6 argumentos opcionales pueden ser solamente especificados
   cuando la ventana es una almohadilla creada con "newpad()".  Los
   parámetros adicionales son necesarios para indicar que parte de la
   almohadilla y pantalla son envueltos.  *pminrow* y *pmincol*
   especifica la esquina superior de la mano izquierda del rectángulo
   a ser mostrado en el *pad*.  *sminrow*, *smincol*, *smaxrow*, y
   *smaxcol* especifica los bordes del rectángulo a ser mostrados en
   la pantalla.  La esquina inferior de la mano derecha del rectángulo
   a ser mostrado en el *pad* es calculado desde las coordenadas de la
   pantalla, desde que el rectángulo debe ser del mismo tamaño.  Ambos
   rectángulos deben ser completamente contenidos con su estructura
   respectiva.  Valores negativos de *pminrow*, *pmincol*, *sminrow*,
   o *smincol* son tratados como si fueran cero.

window.resize(nlines, ncols)

   Redistribuir el almacenamiento para una ventana *curses* para
   ajustar su dimensión para los valores especificados.  Si la
   dimensión también es mayor que los valores actuales, los datos de
   la ventana serán llenados con espacios en blanco que tiene la
   ejecución del fondo actual (como ajustado por "bkgdset()")
   uniéndolos.

window.scroll([lines=1])

   Desplace la pantalla o la región de desplazamiento hacia arriba por
   *lines* líneas.

window.scrollok(flag)

   Control que sucede cuando el cursor de una ventana es movida fuera
   del borde de la ventana o región de desplazamiento, también como un
   resultado de una acción de nueva línea en la línea inferior, o
   escribiendo el último carácter de la última línea.  Si *flag* es
   "False", el cursor está a la izquierda sobre la línea inferior.  Si
   *flag* es "True", la ventana será desplazada hacía arriba por una
   línea.  Note que en orden para obtener el efecto del desplazamiento
   físico en el terminal, también será necesario llamar "idlok()".

window.setscrreg(top, bottom)

   Configura la región de desplazamiento desde la línea *top* hasta la
   línea *bottom*. Todas las acciones de desplazamiento tomarán lugar
   en esta región.

window.standend()

   Desactive el atributo destacado.  En algunos terminales esto tiene
   el efecto secundario de desactivar todos los atributos.

window.standout()

   Active el atributo *A_STANDOUT*.

window.subpad(begin_y, begin_x)
window.subpad(nlines, ncols, begin_y, begin_x)

   Retorna la sub-ventana, cuya esquina superior izquierda esta en
   "(begin_y, begin_x)", y cuyo ancho/alto es *ncols*/*nlines*.

window.subwin(begin_y, begin_x)
window.subwin(nlines, ncols, begin_y, begin_x)

   Retorna la sub-ventana, cuya esquina superior izquierda esta en
   "(begin_y, begin_x)", y cuyo ancho/alto es *ncols*/*nlines*.

   Por defecto, la sub-ventana extenderá desde la posición
   especificada para la esquina inferior derecha de la ventana.

window.syncdown()

   Toca cada ubicación en la ventana que ha sido tocado por alguna de
   sus ventanas padres.  Esta rutina es llamada por "refresh()", esto
   casi nunca debería ser necesario para llamarlo manualmente.

window.syncok(flag)

   Si *flag* es "True", entonces "syncup()" es llamada automáticamente
   cuando hay un cambio en la ventana.

window.syncup()

   Toque todas las locaciones de los ancestros de la ventana que han
   sido cambiados en la ventana.

window.timeout(delay)

   Configura el bloqueo o no bloqueo del comportamiento para la
   ventana.  Si el *delay* es negativo, bloqueando la lectura usada
   (el cual esperará indefinidamente para la entrada).  Si *delay* es
   cero, entonces no se bloqueará la lectura usada, y "getch()"
   retornará "-1" si la entrada no está esperando.  Si *delay* es
   positivo, entonces "getch()" se bloqueará por *delay* milisegundos,
   y retorna "-1" si aún no entra en el final de ese tiempo.

window.touchline(start, count[, changed])

   Supone *count* líneas han sido cambiadas, iniciando con la línea
   *start*.  Si *changed* es suministrado, específica que las líneas
   afectadas son marcadas como hayan sido cambiadas (*changed*"=True")
   o no cambiadas (*changed*"=False").

window.touchwin()

   Suponga que toda la ventana ha sido cambiada, con el fin de
   optimizar el dibujo.

window.untouchwin()

   Marque todas las líneas en la ventana como no cambiadas desde la
   última llamada para "refresh()".

window.vline(ch, n[, attr])
window.vline(y, x, ch, n[, attr])

   Display a vertical line starting at "(y, x)" with length *n*
   consisting of the character *ch* with attributes *attr*.


Constantes
==========

El módulo "curses" define los siguientes miembros de datos:

curses.ERR

   Algunas rutinas de *curses* que retornan un entero, tales como
   "getch()", retorna "ERR" sobre el fallo.

curses.OK

   Algunas rutinas de *curses* que retornan un entero, tales como
   "napms()", retorna "OK" tras el éxito.

curses.version

curses.__version__

   A bytes object representing the current version of the module.

curses.ncurses_version

   Una tupla nombrada contiene los 3 componentes de la versión de la
   librería *ncurses* *major*, *minor*, y *patch*.  Todos los valores
   son enteros.  Los componentes pueden también ser accedidos por
   nombre, así "curses.ncurses_version[0]" es equivalente a
   "curses.ncurses_version.major" y así.

   Disponibilidad: si la librería ncurses es usada.

   Nuevo en la versión 3.8.

curses.COLORS

   The maximum number of colors the terminal can support. It is
   defined only after the call to "start_color()".

curses.COLOR_PAIRS

   The maximum number of color pairs the terminal can support. It is
   defined only after the call to "start_color()".

curses.COLS

   The width of the screen, i.e., the number of columns. It is defined
   only after the call to "initscr()". Updated by
   "update_lines_cols()", "resizeterm()" and "resize_term()".

curses.LINES

   The height of the screen, i.e., the number of lines. It is defined
   only after the call to "initscr()". Updated by
   "update_lines_cols()", "resizeterm()" and "resize_term()".

Algunas constantes están disponibles para especificar los atributos
del celdas de caracteres.  Las constantes exactas disponible dependen
del sistema.

+--------------------------+---------------------------------+
| Atributo                 | Significado                     |
|==========================|=================================|
| curses.A_ALTCHARSET      | Modo de conjunto de caracteres  |
|                          | alternativo                     |
+--------------------------+---------------------------------+
| curses.A_BLINK           | Modo parpadeo                   |
+--------------------------+---------------------------------+
| curses.A_BOLD            | Modo negrita                    |
+--------------------------+---------------------------------+
| curses.A_DIM             | Modo tenue                      |
+--------------------------+---------------------------------+
| curses.A_INVIS           | Modo invisible o en blanco      |
+--------------------------+---------------------------------+
| curses.A_ITALIC          | Modo cursiva                    |
+--------------------------+---------------------------------+
| curses.A_NORMAL          | Atributo normal                 |
+--------------------------+---------------------------------+
| curses.A_PROTECT         | Modo protegido                  |
+--------------------------+---------------------------------+
| curses.A_REVERSE         | Fondo inverso y colores de      |
|                          | primer plano                    |
+--------------------------+---------------------------------+
| curses.A_STANDOUT        | Modo destacado                  |
+--------------------------+---------------------------------+
| curses.A_UNDERLINE       | Modo subrayado                  |
+--------------------------+---------------------------------+
| curses.A_HORIZONTAL      | Resaltado horizontal            |
+--------------------------+---------------------------------+
| curses.A_LEFT            | Resaltado a la izquierda        |
+--------------------------+---------------------------------+
| curses.A_LOW             | Resaltado bajo                  |
+--------------------------+---------------------------------+
| curses.A_RIGHT           | Resaltado a la derecha          |
+--------------------------+---------------------------------+
| curses.A_TOP             | Resaltado arriba                |
+--------------------------+---------------------------------+
| curses.A_VERTICAL        | Resaltado vertical              |
+--------------------------+---------------------------------+

Nuevo en la versión 3.7: "A_ITALIC" fue añadido.

Varias constantes están disponibles para extraer los atributos
correspondientes retornados por algunos métodos.

+---------------------------+---------------------------------+
| Mascara de bits           | Significado                     |
|===========================|=================================|
| curses.A_ATTRIBUTES       | Mascara de bits para extraer    |
|                           | atributos                       |
+---------------------------+---------------------------------+
| curses.A_CHARTEXT         | Mascara de bits para extraer un |
|                           | caracter                        |
+---------------------------+---------------------------------+
| curses.A_COLOR            | Mascara de bits para extraer    |
|                           | información de campo de pares   |
|                           | de colores                      |
+---------------------------+---------------------------------+

Las teclas se denominan constantes enteras con nombres que comienzan
con "KEY_". Las teclas exactas disponibles son dependientes del
sistema.

+---------------------------+----------------------------------------------+
| Clave constante           | Clave                                        |
|===========================|==============================================|
| curses.KEY_MIN            | Valor mínimo de la clave                     |
+---------------------------+----------------------------------------------+
| curses.KEY_BREAK          | Clave rota (no confiable)                    |
+---------------------------+----------------------------------------------+
| curses.KEY_DOWN           | Flecha hacia abajo                           |
+---------------------------+----------------------------------------------+
| curses.KEY_UP             | Flecha hacia arriba                          |
+---------------------------+----------------------------------------------+
| curses.KEY_LEFT           | Flecha hacia la izquierda                    |
+---------------------------+----------------------------------------------+
| curses.KEY_RIGHT          | Flecha hacia la derecha                      |
+---------------------------+----------------------------------------------+
| curses.KEY_HOME           | Tecla de inicio (flecha hacia arriba +       |
|                           | flecha hacia la izquierda)                   |
+---------------------------+----------------------------------------------+
| curses.KEY_BACKSPACE      | Retroceso (no confiable)                     |
+---------------------------+----------------------------------------------+
| curses.KEY_F0             | Teclas de función. Más de 64 teclas de       |
|                           | función son soportadas.                      |
+---------------------------+----------------------------------------------+
| curses.KEY_Fn             | Valor de tecla de función *n*                |
+---------------------------+----------------------------------------------+
| curses.KEY_DL             | Borrar línea                                 |
+---------------------------+----------------------------------------------+
| curses.KEY_IL             | Inserte línea                                |
+---------------------------+----------------------------------------------+
| curses.KEY_DC             | Borrar caracter                              |
+---------------------------+----------------------------------------------+
| curses.KEY_IC             | Insertar carácter o ingresara al modo de     |
|                           | inserción                                    |
+---------------------------+----------------------------------------------+
| curses.KEY_EIC            | Salir del modo de inserción de caracteres    |
+---------------------------+----------------------------------------------+
| curses.KEY_CLEAR          | Limpiar pantalla                             |
+---------------------------+----------------------------------------------+
| curses.KEY_EOS            | Limpiar al final de pantalla                 |
+---------------------------+----------------------------------------------+
| curses.KEY_EOL            | Limpiar al final de la línea                 |
+---------------------------+----------------------------------------------+
| curses.KEY_SF             | Desplazar una línea hacia adelante           |
+---------------------------+----------------------------------------------+
| curses.KEY_SR             | Desplazar una línea hacia atrás (reversa)    |
+---------------------------+----------------------------------------------+
| curses.KEY_NPAGE          | Página siguiente                             |
+---------------------------+----------------------------------------------+
| curses.KEY_PPAGE          | Página anterior                              |
+---------------------------+----------------------------------------------+
| curses.KEY_STAB           | Establecer pestaña                           |
+---------------------------+----------------------------------------------+
| curses.KEY_CTAB           | Limpiar pestaña                              |
+---------------------------+----------------------------------------------+
| curses.KEY_CATAB          | Limpiar todas las pestañas                   |
+---------------------------+----------------------------------------------+
| curses.KEY_ENTER          | Ingresar o enviar (no confiable)             |
+---------------------------+----------------------------------------------+
| curses.KEY_SRESET         | Reinicio suave (parcial) (no confiable)      |
+---------------------------+----------------------------------------------+
| curses.KEY_RESET          | Reinicio o reinicio fuerte (no confiable)    |
+---------------------------+----------------------------------------------+
| curses.KEY_PRINT          | Imprimir                                     |
+---------------------------+----------------------------------------------+
| curses.KEY_LL             | Inicio abajo o abajo (abajo a la izquierda)  |
+---------------------------+----------------------------------------------+
| curses.KEY_A1             | Superior izquierda del teclado               |
+---------------------------+----------------------------------------------+
| curses.KEY_A3             | Superior derecha de el teclado               |
+---------------------------+----------------------------------------------+
| curses.KEY_B2             | Centro del teclado                           |
+---------------------------+----------------------------------------------+
| curses.KEY_C1             | Inferior izquierdo del teclado               |
+---------------------------+----------------------------------------------+
| curses.KEY_C3             | Inferior derecho del teclado                 |
+---------------------------+----------------------------------------------+
| curses.KEY_BTAB           | Pestaña trasera                              |
+---------------------------+----------------------------------------------+
| curses.KEY_BEG            | Mendigar (Comienzo)                          |
+---------------------------+----------------------------------------------+
| curses.KEY_CANCEL         | Cancelar                                     |
+---------------------------+----------------------------------------------+
| curses.KEY_CLOSE          | Cerrar                                       |
+---------------------------+----------------------------------------------+
| curses.KEY_COMMAND        | Cmd (Comando)                                |
+---------------------------+----------------------------------------------+
| curses.KEY_COPY           | Copiar                                       |
+---------------------------+----------------------------------------------+
| curses.KEY_CREATE         | Crear                                        |
+---------------------------+----------------------------------------------+
| curses.KEY_END            | Final                                        |
+---------------------------+----------------------------------------------+
| curses.KEY_EXIT           | Salir                                        |
+---------------------------+----------------------------------------------+
| curses.KEY_FIND           | Encontrar                                    |
+---------------------------+----------------------------------------------+
| curses.KEY_HELP           | Ayudar                                       |
+---------------------------+----------------------------------------------+
| curses.KEY_MARK           | Marca                                        |
+---------------------------+----------------------------------------------+
| curses.KEY_MESSAGE        | Mensaje                                      |
+---------------------------+----------------------------------------------+
| curses.KEY_MOVE           | Mover                                        |
+---------------------------+----------------------------------------------+
| curses.KEY_NEXT           | Siguiente                                    |
+---------------------------+----------------------------------------------+
| curses.KEY_OPEN           | Abrir                                        |
+---------------------------+----------------------------------------------+
| curses.KEY_OPTIONS        | Opciones                                     |
+---------------------------+----------------------------------------------+
| curses.KEY_PREVIOUS       | Anterior                                     |
+---------------------------+----------------------------------------------+
| curses.KEY_REDO           | Rehacer                                      |
+---------------------------+----------------------------------------------+
| curses.KEY_REFERENCE      | Referencia                                   |
+---------------------------+----------------------------------------------+
| curses.KEY_REFRESH        | Refrescar                                    |
+---------------------------+----------------------------------------------+
| curses.KEY_REPLACE        | Re-emplazar                                  |
+---------------------------+----------------------------------------------+
| curses.KEY_RESTART        | Re-iniciar                                   |
+---------------------------+----------------------------------------------+
| curses.KEY_RESUME         | Resumir                                      |
+---------------------------+----------------------------------------------+
| curses.KEY_SAVE           | Guardar                                      |
+---------------------------+----------------------------------------------+
| curses.KEY_SBEG           | Mendicidad desplazada (comienzo)             |
+---------------------------+----------------------------------------------+
| curses.KEY_SCANCEL        | Cancelar cambiado                            |
+---------------------------+----------------------------------------------+
| curses.KEY_SCOMMAND       | Comando cambiado                             |
+---------------------------+----------------------------------------------+
| curses.KEY_SCOPY          | Copiado cambiado                             |
+---------------------------+----------------------------------------------+
| curses.KEY_SCREATE        | Crear con desplazamiento                     |
+---------------------------+----------------------------------------------+
| curses.KEY_SDC            | Borrar carácter desplazado                   |
+---------------------------+----------------------------------------------+
| curses.KEY_SDL            | Borrar línea desplazada                      |
+---------------------------+----------------------------------------------+
| curses.KEY_SELECT         | Seleccionar                                  |
+---------------------------+----------------------------------------------+
| curses.KEY_SEND           | Final desplazado                             |
+---------------------------+----------------------------------------------+
| curses.KEY_SEOL           | Limpiar línea desplazada                     |
+---------------------------+----------------------------------------------+
| curses.KEY_SEXIT          | Salida desplazada                            |
+---------------------------+----------------------------------------------+
| curses.KEY_SFIND          | Búsqueda desplazada                          |
+---------------------------+----------------------------------------------+
| curses.KEY_SHELP          | Ayuda desplazada                             |
+---------------------------+----------------------------------------------+
| curses.KEY_SHOME          | Inicio cambiado                              |
+---------------------------+----------------------------------------------+
| curses.KEY_SIC            | Entrada cambiada                             |
+---------------------------+----------------------------------------------+
| curses.KEY_SLEFT          | Flecha hacia la izquierda desplazada         |
+---------------------------+----------------------------------------------+
| curses.KEY_SMESSAGE       | Mensaje cambiado                             |
+---------------------------+----------------------------------------------+
| curses.KEY_SMOVE          | Movimiento desplazado                        |
+---------------------------+----------------------------------------------+
| curses.KEY_SNEXT          | Siguiente desplazado                         |
+---------------------------+----------------------------------------------+
| curses.KEY_SOPTIONS       | Opciones cambiadas                           |
+---------------------------+----------------------------------------------+
| curses.KEY_SPREVIOUS      | Anterior cambiado                            |
+---------------------------+----------------------------------------------+
| curses.KEY_SPRINT         | Imprimir desplazado                          |
+---------------------------+----------------------------------------------+
| curses.KEY_SREDO          | Rehacer cambiado                             |
+---------------------------+----------------------------------------------+
| curses.KEY_SREPLACE       | Re-emplazo cambiado                          |
+---------------------------+----------------------------------------------+
| curses.KEY_SRIGHT         | Flecha hacia la derecha cambiada             |
+---------------------------+----------------------------------------------+
| curses.KEY_SRSUME         | Resumen cambiado                             |
+---------------------------+----------------------------------------------+
| curses.KEY_SSAVE          | Guardar desplazado                           |
+---------------------------+----------------------------------------------+
| curses.KEY_SSUSPEND       | Suspender cambiado                           |
+---------------------------+----------------------------------------------+
| curses.KEY_SUNDO          | Deshacer desplazado                          |
+---------------------------+----------------------------------------------+
| curses.KEY_SUSPEND        | Suspender                                    |
+---------------------------+----------------------------------------------+
| curses.KEY_UNDO           | Deshacer                                     |
+---------------------------+----------------------------------------------+
| curses.KEY_MOUSE          | Evento del ratón ha ocurrido                 |
+---------------------------+----------------------------------------------+
| curses.KEY_RESIZE         | Evento de cambio de tamaño del terminal      |
+---------------------------+----------------------------------------------+
| curses.KEY_MAX            | Valor máximo de clave                        |
+---------------------------+----------------------------------------------+

On VT100s and their software emulations, such as X terminal emulators,
there are normally at least four function keys ("KEY_F1", "KEY_F2",
"KEY_F3", "KEY_F4") available, and the arrow keys mapped to "KEY_UP",
"KEY_DOWN", "KEY_LEFT" and "KEY_RIGHT" in the obvious way.  If your
machine has a PC keyboard, it is safe to expect arrow keys and twelve
function keys (older PC keyboards may have only ten function keys);
also, the following keypad mappings are standard:

+--------------------+-------------+
| Tecla              | Constante   |
|====================|=============|
| "Insert"           | KEY_IC      |
+--------------------+-------------+
| "Delete"           | KEY_DC      |
+--------------------+-------------+
| "Home"             | KEY_HOME    |
+--------------------+-------------+
| "End"              | KEY_END     |
+--------------------+-------------+
| "Page Up"          | KEY_PPAGE   |
+--------------------+-------------+
| "Page Down"        | KEY_NPAGE   |
+--------------------+-------------+

La siguiente tabla lista los caracteres desde el conjunto alterno de
caracteres.  Estos son heredados desde el terminal VT100, y
generalmente estará disponible en emuladores de software tales como
terminales X.  Cuando no hay gráficos disponibles, *curses* cae en una
aproximación cruda de ASCII imprimibles.

Nota:

  Estos están disponibles solamente después de que "initscr()" ha sido
  llamada.

+--------------------------+--------------------------------------------+
| Código ACS               | Significado                                |
|==========================|============================================|
| curses.ACS_BBSS          | nombre alternativo para la esquina         |
|                          | superior derecha                           |
+--------------------------+--------------------------------------------+
| curses.ACS_BLOCK         | bloque cuadrado sólido                     |
+--------------------------+--------------------------------------------+
| curses.ACS_BOARD         | tablero de cuadrados                       |
+--------------------------+--------------------------------------------+
| curses.ACS_BSBS          | nombre alternativo para línea horizontal   |
+--------------------------+--------------------------------------------+
| curses.ACS_BSSB          | nombre alternativo para esquina superior   |
|                          | izquierda                                  |
+--------------------------+--------------------------------------------+
| curses.ACS_BSSS          | nombre alternativo para el soporte         |
|                          | superior                                   |
+--------------------------+--------------------------------------------+
| curses.ACS_BTEE          | soporte inferior                           |
+--------------------------+--------------------------------------------+
| curses.ACS_BULLET        | bala                                       |
+--------------------------+--------------------------------------------+
| curses.ACS_CKBOARD       | tablero inspector (punteado)               |
+--------------------------+--------------------------------------------+
| curses.ACS_DARROW        | flecha punteada hacia abajo                |
+--------------------------+--------------------------------------------+
| curses.ACS_DEGREE        | símbolo de grado                           |
+--------------------------+--------------------------------------------+
| curses.ACS_DIAMOND       | diamante                                   |
+--------------------------+--------------------------------------------+
| curses.ACS_GEQUAL        | mayor que o igual a                        |
+--------------------------+--------------------------------------------+
| curses.ACS_HLINE         | línea horizontal                           |
+--------------------------+--------------------------------------------+
| curses.ACS_LANTERN       | símbolo de la linterna                     |
+--------------------------+--------------------------------------------+
| curses.ACS_LARROW        | flecha izquierda                           |
+--------------------------+--------------------------------------------+
| curses.ACS_LEQUAL        | menor que o igual a                        |
+--------------------------+--------------------------------------------+
| curses.ACS_LLCORNER      | esquina inferior izquierda                 |
+--------------------------+--------------------------------------------+
| curses.ACS_LRCORNER      | esquina inferior derecha                   |
+--------------------------+--------------------------------------------+
| curses.ACS_LTEE          | soporte izquierdo                          |
+--------------------------+--------------------------------------------+
| curses.ACS_NEQUAL        | signo no igual                             |
+--------------------------+--------------------------------------------+
| curses.ACS_PI            | letra pi                                   |
+--------------------------+--------------------------------------------+
| curses.ACS_PLMINUS       | signo más o menos                          |
+--------------------------+--------------------------------------------+
| curses.ACS_PLUS          | gran signo más                             |
+--------------------------+--------------------------------------------+
| curses.ACS_RARROW        | flecha hacia la derecha                    |
+--------------------------+--------------------------------------------+
| curses.ACS_RTEE          | soporte derecho                            |
+--------------------------+--------------------------------------------+
| curses.ACS_S1            | escanear línea 1                           |
+--------------------------+--------------------------------------------+
| curses.ACS_S3            | escanear línea 3                           |
+--------------------------+--------------------------------------------+
| curses.ACS_S7            | escanear línea 7                           |
+--------------------------+--------------------------------------------+
| curses.ACS_S9            | escanear línea 9                           |
+--------------------------+--------------------------------------------+
| curses.ACS_SBBS          | nombre alterno para la esquina inferior    |
|                          | derecha                                    |
+--------------------------+--------------------------------------------+
| curses.ACS_SBSB          | nombre alterno para la línea vertical      |
+--------------------------+--------------------------------------------+
| curses.ACS_SBSS          | nombre alterno para el soporte derecho     |
+--------------------------+--------------------------------------------+
| curses.ACS_SSBB          | nombre alterno para la esquina inferior    |
|                          | izquierda                                  |
+--------------------------+--------------------------------------------+
| curses.ACS_SSBS          | nombre alterno para el soporte inferior    |
+--------------------------+--------------------------------------------+
| curses.ACS_SSSB          | nombre alterno para el soporte izquierdo   |
+--------------------------+--------------------------------------------+
| curses.ACS_SSSS          | nombre alterno para *crossover* o un gran  |
|                          | más                                        |
+--------------------------+--------------------------------------------+
| curses.ACS_STERLING      | libra esterlina                            |
+--------------------------+--------------------------------------------+
| curses.ACS_TTEE          | soporte superior                           |
+--------------------------+--------------------------------------------+
| curses.ACS_UARROW        | flecha hacia arriba                        |
+--------------------------+--------------------------------------------+
| curses.ACS_ULCORNER      | esquina superior izquierda                 |
+--------------------------+--------------------------------------------+
| curses.ACS_URCORNER      | esquina superior derecha                   |
+--------------------------+--------------------------------------------+
| curses.ACS_VLINE         | línea vertical                             |
+--------------------------+--------------------------------------------+

The following table lists mouse button constants used by "getmouse()":

+------------------------------------+-----------------------------------------------+
| Mouse button constant              | Significado                                   |
|====================================|===============================================|
| curses.BUTTONn_PRESSED             | Mouse button *n* pressed                      |
+------------------------------------+-----------------------------------------------+
| curses.BUTTONn_RELEASED            | Mouse button *n* released                     |
+------------------------------------+-----------------------------------------------+
| curses.BUTTONn_CLICKED             | Mouse button *n* clicked                      |
+------------------------------------+-----------------------------------------------+
| curses.BUTTONn_DOUBLE_CLICKED      | Mouse button *n* double clicked               |
+------------------------------------+-----------------------------------------------+
| curses.BUTTONn_TRIPLE_CLICKED      | Mouse button *n* triple clicked               |
+------------------------------------+-----------------------------------------------+
| curses.BUTTON_SHIFT                | Shift was down during button state change     |
+------------------------------------+-----------------------------------------------+
| curses.BUTTON_CTRL                 | Control was down during button state change   |
+------------------------------------+-----------------------------------------------+
| curses.BUTTON_ALT                  | Control was down during button state change   |
+------------------------------------+-----------------------------------------------+

Distinto en la versión 3.10: Las constantes "BUTTON5_*" ahora están
expuestas si son proporcionadas por la biblioteca curses subyacente.

La siguiente tabla lista los colores pre-definidos:

+---------------------------+------------------------------+
| Constante                 | Color                        |
|===========================|==============================|
| curses.COLOR_BLACK        | Negro                        |
+---------------------------+------------------------------+
| curses.COLOR_BLUE         | Azul                         |
+---------------------------+------------------------------+
| curses.COLOR_CYAN         | Cian (azul verdoso claro)    |
+---------------------------+------------------------------+
| curses.COLOR_GREEN        | Verde                        |
+---------------------------+------------------------------+
| curses.COLOR_MAGENTA      | Magenta (rojo violáceo)      |
+---------------------------+------------------------------+
| curses.COLOR_RED          | Rojo                         |
+---------------------------+------------------------------+
| curses.COLOR_WHITE        | Blanco                       |
+---------------------------+------------------------------+
| curses.COLOR_YELLOW       | Amarillo                     |
+---------------------------+------------------------------+


"curses.textpad"--- Widget de entrada de texto para programas de curses
***********************************************************************

El módulo "curses.textpad" provee una clase "Textbox" que maneja
edición de texto primario en una ventana *curses*, apoyando un
conjunto de atajos de teclado re-ensamblando estos de Emacs (esto,
también de *Netscape Navigator*, BBedit 6.x, FrameMaker, y muchos
otros programas).  Los módulos también proveen una función de dibujo
de rectángulo útil para enmarcar las cajas de texto o para otros
propósitos.

El módulo "curses.textpad" define la siguiente función:

curses.textpad.rectangle(win, uly, ulx, lry, lrx)

   Dibuja un rectángulo.  El primer argumento debe ser un objeto de
   ventana, los argumentos restantes son coordenadas relativas para
   esa ventana.  El segundo y tercer argumento son las coordenadas 'x'
   y 'y' de la esquina superior de la mano izquierda del rectángulo a
   ser dibujado, el cuarto y quinto argumento son las coordenadas 'x'
   y 'y' de la esquina inferior de la mano derecha.  El rectángulo
   será dibujado usando formularios de caracteres VT100/IBM PC en
   terminales que hace esto posible (incluyendo *xterm* y mas otro
   emulador de terminal de software).  Por otra parte será dibujado
   con guiones, barras verticales, y signos de más de ASCII.


Objeto de caja de texto
=======================

Tú puedes instanciar un objeto "Textbox" como sigue:

class curses.textpad.Textbox(win)

   Retorna un objeto *widget* de caja de texto.  El argumento *win*
   debería ser un objeto *curses* window en el cual la caja de texto
   es para ser contenido.  El cursor de la caja de texto está
   inicialmente localizado en la esquina superior de la mano izquierda
   de la ventana que lo contiene, con coordenadas "(0, 0)".  La
   bandera instanciada "stripspaces" está inicialmente encendida.

   Objeto "Textbox" tiene los siguientes métodos:

   edit([validator])

      Este es el punto de entrada que normalmente usarás.  Esto acepta
      la edición de las pulsaciones de tecla hasta que uno de las
      pulsaciones de finalización es introducida.  Si *validator* es
      suministrado, esto debe ser una función.  Será llamado para cada
      pulsación de tecla introducida con la pulsación de tecla como un
      parámetro; el comando ejecutado está hecho en el resultado.
      Este método retorna el contenido de la ventana como una cadena
      de caracteres; si se incluyen espacios en blanco en la ventana
      se ve afectado por el atributo "stripspaces".

   do_command(ch)

      Procesa un simple comando al pulsar una tecla.  Aquí está las
      funciones de tecla especiales admitidas:

      +--------------------+---------------------------------------------+
      | Pulsación de tecla | Acción                                      |
      |====================|=============================================|
      | "Control-A"        | Ve al borde izquierdo de la ventana.        |
      +--------------------+---------------------------------------------+
      | "Control-B"        | Cursor hacia la izquierda, pasando a la     |
      |                    | línea anterior si corresponde.              |
      +--------------------+---------------------------------------------+
      | "Control-D"        | Borra el carácter bajo el cursor.           |
      +--------------------+---------------------------------------------+
      | "Control-E"        | Ve al borde derecho (quita los espacios) o  |
      |                    | al final de línea (eliminar los espacios).  |
      +--------------------+---------------------------------------------+
      | "Control-F"        | Cursor hacia la derecha, pasando a la línea |
      |                    | siguiente cuando corresponda.               |
      +--------------------+---------------------------------------------+
      | "Control-G"        | Terminar, retornando el contenido de la     |
      |                    | ventana.                                    |
      +--------------------+---------------------------------------------+
      | "Control-H"        | Eliminar carácter al revés.                 |
      +--------------------+---------------------------------------------+
      | "Control-J"        | Terminar si la ventana es de 1 línea, en    |
      |                    | caso contrario, inserte una nueva línea.    |
      +--------------------+---------------------------------------------+
      | "Control-K"        | Si la línea es blanca bórrela, en caso      |
      |                    | contrario, limpie hasta el final de línea.  |
      +--------------------+---------------------------------------------+
      | "Control-L"        | Refrescar la pantalla.                      |
      +--------------------+---------------------------------------------+
      | "Control-N"        | Cursor hacia abajo; mueve hacia abajo una   |
      |                    | línea.                                      |
      +--------------------+---------------------------------------------+
      | "Control-O"        | Inserte una línea en blanco en la posición  |
      |                    | del cursor.                                 |
      +--------------------+---------------------------------------------+
      | "Control-P"        | Cursor hacia arriba; mueve hacia arriba una |
      |                    | línea.                                      |
      +--------------------+---------------------------------------------+

      Las operaciones de movimiento no hacen nada si el cursor está en
      un borde donde el movimiento no es posible. Los siguientes
      sinónimos están apoyados siempre que sea posible:

      +----------------------------------+--------------------+
      | Constante                        | Pulsación de tecla |
      |==================================|====================|
      | "KEY_LEFT"                       | "Control-B"        |
      +----------------------------------+--------------------+
      | "KEY_RIGHT"                      | "Control-F"        |
      +----------------------------------+--------------------+
      | "KEY_UP"                         | "Control-P"        |
      +----------------------------------+--------------------+
      | "KEY_DOWN"                       | "Control-N"        |
      +----------------------------------+--------------------+
      | "KEY_BACKSPACE"                  | "Control-h"        |
      +----------------------------------+--------------------+

      Todas las otras pulsaciones de teclas están tratadas como un
      comando para insertar el carácter dado y muévase a la derecha
      (con ajuste en la línea).

   gather()

      Retorne el contenido de la ventana como una cadena de texto; si
      se incluyen espacios en blanco en la ventana se ve afectado por
      el miembro "stripspaces".

   stripspaces

      Este atributo es una bandera que controla la interpretación de
      los espacios en blanco en la ventana.  Cuando está encendido,
      los espacios en blanco al final en cada línea son ignorados;
      cualquier movimiento del cursor que lo coloque en un espacio en
      blanco final va hasta el final de esa línea, y los espacios en
      blanco finales son despejados cuando se recopila el contenido de
      la ventana.
