curses.po

# Copyright (C) 2001-2020, Python Software Foundation
# This file is distributed under the same license as the Python package.
# Maintained by the python-doc-es workteam.
# docs-es@python.org /
# https://mail.python.org/mailman3/lists/docs-es.python.org/
# Check https://github.com/PyCampES/python-docs-es/blob/3.8/TRANSLATORS to
# get the list of volunteers
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-10-12 19:43+0200\n"
"PO-Revision-Date: 2023-03-20 17:27-0600\n"
"Last-Translator: Juan Diego Alfonso Ocampo <juandiego.alfonsoocampo@gmail."
"com>\n"
"Language: es\n"
"Language-Team: python-doc-es\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.13.0\n"

#: ../Doc/howto/curses.rst:5
msgid "Curses Programming with Python"
msgstr "Programación de curses con Python"

#: ../Doc/howto/curses.rst
msgid "Author"
msgstr "Autor"

#: ../Doc/howto/curses.rst:9
msgid "A.M. Kuchling, Eric S. Raymond"
msgstr "A.M. Kuchling, Eric S. Raymond"

#: ../Doc/howto/curses.rst
msgid "Release"
msgstr "Versión"

#: ../Doc/howto/curses.rst:10
msgid "2.04"
msgstr "2.04"

msgid "Abstract"
msgstr "Resumen"

#: ../Doc/howto/curses.rst:15
msgid ""
"This document describes how to use the :mod:`curses` extension module to "
"control text-mode displays."
msgstr ""
"Este documento describe cómo usar el módulo de extensión :mod:`curses` para "
"controlar las pantallas en modo texto."

#: ../Doc/howto/curses.rst:20
msgid "What is curses?"
msgstr "¿Qué es curses?"

#: ../Doc/howto/curses.rst:22
msgid ""
"The curses library supplies a terminal-independent screen-painting and "
"keyboard-handling facility for text-based terminals; such terminals include "
"VT100s, the Linux console, and the simulated terminal provided by various "
"programs.  Display terminals support various control codes to perform common "
"operations such as moving the cursor, scrolling the screen, and erasing "
"areas.  Different terminals use widely differing codes, and often have their "
"own minor quirks."
msgstr ""
"La biblioteca curses proporciona una instalación independiente del terminal "
"para manejo de teclado e impresión de pantalla en terminales basados en "
"texto; tales terminales incluyen VT100, la consola de Linux y el terminal "
"simulado proporcionado por varios programas. Los terminales de pantalla "
"admiten varios códigos de control para realizar operaciones comunes, como "
"mover el cursor, desplazar la pantalla y borrar áreas. Diferentes terminales "
"utilizan códigos muy diferentes y, a menudo, tienen sus propias "
"peculiaridades menores."

#: ../Doc/howto/curses.rst:30
msgid ""
"In a world of graphical displays, one might ask \"why bother\"?  It's true "
"that character-cell display terminals are an obsolete technology, but there "
"are niches in which being able to do fancy things with them are still "
"valuable.  One niche is on small-footprint or embedded Unixes that don't run "
"an X server.  Another is tools such as OS installers and kernel "
"configurators that may have to run before any graphical support is available."
msgstr ""
"En un mundo de pantallas gráficas, uno podría preguntarse « ¿por qué "
"molestarse »? Es cierto que los terminales de pantalla de celdas de "
"caracteres son una tecnología obsoleta, pero hay nichos en los que poder "
"hacer cosas elegantes con ellos sigue siendo valioso. Un nicho está en "
"pequeños *Unix* incrustados o pequeñas marcas que no ejecutan un servidor X. "
"Por otro lado herramientas como los instaladores del sistema operativo y los "
"configuradores de kernel que pueden tener que ejecutarse antes de que haya "
"soporte gráfico disponible."

#: ../Doc/howto/curses.rst:38
msgid ""
"The curses library provides fairly basic functionality, providing the "
"programmer with an abstraction of a display containing multiple non-"
"overlapping windows of text.  The contents of a window can be changed in "
"various ways---adding text, erasing it, changing its appearance---and the "
"curses library will figure out what control codes need to be sent to the "
"terminal to produce the right output.  curses doesn't provide many user-"
"interface concepts such as buttons, checkboxes, or dialogs; if you need such "
"features, consider a user interface library such as `Urwid <https://pypi.org/"
"project/urwid/>`_."
msgstr ""
"La biblioteca curses proporciona una funcionalidad bastante básica, "
"proporcionando al programador una abstracción de una pantalla que contiene "
"múltiples ventanas de texto no superpuestas. El contenido de una ventana se "
"puede cambiar de varias maneras (agregando texto, borrándolo, cambiando su "
"apariencia) y la biblioteca curses descubrirá que códigos de control deben "
"enviarse al terminal para producir la salida correcta. curses no proporciona "
"muchos conceptos de interfaz de usuario como botones, casillas de "
"verificación o cuadros de diálogo; Si necesita tales funciones, considere "
"una biblioteca de interfaz de usuario como `Urwid <https://pypi.org/project/"
"urwid/>`_."

#: ../Doc/howto/curses.rst:48
msgid ""
"The curses library was originally written for BSD Unix; the later System V "
"versions of Unix from AT&T added many enhancements and new functions. BSD "
"curses is no longer maintained, having been replaced by ncurses, which is an "
"open-source implementation of the AT&T interface.  If you're using an open-"
"source Unix such as Linux or FreeBSD, your system almost certainly uses "
"ncurses.  Since most current commercial Unix versions are based on System V "
"code, all the functions described here will probably be available.  The "
"older versions of curses carried by some proprietary Unixes may not support "
"everything, though."
msgstr ""
"La biblioteca curses se escribió originalmente para BSD Unix; Las versiones "
"posteriores de Unix de *System V* de AT&T agregaron muchas mejoras y nuevas "
"funciones. BSD curses ya no se mantiene, ya que ha sido reemplazado por "
"ncurses, que es una implementación de código abierto de la interfaz AT&T. Si "
"está utilizando un Unix de código abierto como Linux o FreeBSD, su sistema "
"casi seguro usa ncurses. Como la mayoría de las versiones comerciales "
"actuales de Unix se basan en el código del Sistema V, todas las funciones "
"descritas aquí probablemente estarán disponibles. Sin embargo, las versiones "
"anteriores de curses llevadas por algunos Unix propietarios no pueden "
"admitir todo."

#: ../Doc/howto/curses.rst:58
msgid ""
"The Windows version of Python doesn't include the :mod:`curses` module.  A "
"ported version called `UniCurses <https://pypi.org/project/UniCurses>`_ is "
"available."
msgstr ""
"La versión de Python para Windows no incluye el módulo :mod:`curses`. Existe "
"una versión adaptada llamada `UniCurses <https://pypi.org/project/"
"UniCurses>`_ disponible."

#: ../Doc/howto/curses.rst:64
msgid "The Python curses module"
msgstr "El módulo curses de Python"

#: ../Doc/howto/curses.rst:66
#, fuzzy
msgid ""
"The Python module is a fairly simple wrapper over the C functions provided "
"by curses; if you're already familiar with curses programming in C, it's "
"really easy to transfer that knowledge to Python.  The biggest difference is "
"that the Python interface makes things simpler by merging different C "
"functions such as :c:func:`!addstr`, :c:func:`!mvaddstr`, and :c:func:`!"
"mvwaddstr` into a single :meth:`~curses.window.addstr` method.  You'll see "
"this covered in more detail later."
msgstr ""
"El módulo Python es un envoltorio bastante simple sobre las funciones C "
"proporcionadas por curses; si ya está familiarizado con la programación de "
"curses en C, es muy fácil transferir ese conocimiento a Python. La mayor "
"diferencia es que la interfaz de Python simplifica las cosas al combinar "
"diferentes funciones de C como :c:func:`addtr` , :c:func:`mvaddstr` , y :c:"
"func:`mvwaddstr` en un solo método :meth:`~curses.window.addstr`. Verá esto "
"cubierto con más detalle más adelante."

#: ../Doc/howto/curses.rst:74
msgid ""
"This HOWTO is an introduction to writing text-mode programs with curses and "
"Python. It doesn't attempt to be a complete guide to the curses API; for "
"that, see the Python library guide's section on ncurses, and the C manual "
"pages for ncurses.  It will, however, give you the basic ideas."
msgstr ""
"Este HOWTO es una introducción a la escritura de programas en modo texto con "
"curses y Python. No intenta ser una guía completa de la API de curses; para "
"eso, vea la sección de la guía de la biblioteca de Python sobre ncurses, y "
"las páginas del manual de C para ncurses. Sin embargo, le dará las ideas "
"básicas."

#: ../Doc/howto/curses.rst:81
msgid "Starting and ending a curses application"
msgstr "Iniciar y finalizar una aplicación de curses"

#: ../Doc/howto/curses.rst:83
#, fuzzy
msgid ""
"Before doing anything, curses must be initialized.  This is done by calling "
"the :func:`~curses.initscr` function, which will determine the terminal "
"type, send any required setup codes to the terminal, and create various "
"internal data structures.  If successful, :func:`!initscr` returns a window "
"object representing the entire screen; this is usually called ``stdscr`` "
"after the name of the corresponding C variable. ::"
msgstr ""
"Antes de hacer cualquier cosa, curses deben ser inicializadas. Esto se "
"realiza llamando a la función :func:`~curses.initscr`, que determinará el "
"tipo de terminal, enviará los códigos de configuración necesarios al "
"terminal y creará varias estructuras de datos internas. Si tiene éxito, :"
"func:`initscr` retorna un objeto de ventana que representa la pantalla "
"completa; Esto generalmente se llama ``stdscr`` después del nombre de la "
"variable C correspondiente. ::"

#: ../Doc/howto/curses.rst:94
msgid ""
"Usually curses applications turn off automatic echoing of keys to the "
"screen, in order to be able to read keys and only display them under certain "
"circumstances.  This requires calling the :func:`~curses.noecho` function. ::"
msgstr ""
"Por lo general, las aplicaciones de curses desactivan el eco automático de "
"las teclas en la pantalla, para poder leer las teclas y solo mostrarlas bajo "
"ciertas circunstancias. Esto requiere llamar a la función :func:`~curses."
"noecho` function. ::"

#: ../Doc/howto/curses.rst:101
msgid ""
"Applications will also commonly need to react to keys instantly, without "
"requiring the Enter key to be pressed; this is called cbreak mode, as "
"opposed to the usual buffered input mode. ::"
msgstr ""
"Las aplicaciones también tendrán que reaccionar a las teclas al instante, "
"sin necesidad de presionar la tecla Intro; Esto se llama modo cbreak, en "
"oposición al modo de entrada almacenado en memoria intermedia habitual. ::"

#: ../Doc/howto/curses.rst:107
msgid ""
"Terminals usually return special keys, such as the cursor keys or navigation "
"keys such as Page Up and Home, as a multibyte escape sequence.  While you "
"could write your application to expect such sequences and process them "
"accordingly, curses can do it for you, returning a special value such as :"
"const:`curses.KEY_LEFT`.  To get curses to do the job, you'll have to enable "
"keypad mode. ::"
msgstr ""
"Los terminales generalmente retornan teclas especiales, como las teclas del "
"cursor o las teclas de navegación, como Re Pág e Inicio, como una secuencia "
"de escape multibyte. Si bien puede escribir su aplicación para esperar tales "
"secuencias y procesarlas en consecuencia, curses pueden hacerlo por usted, "
"retornando un valor especial como :const:`curses.KEY_LEFT`. Para obtener que "
"curses haga el trabajo, deberá habilitar el modo de teclado. ::"

#: ../Doc/howto/curses.rst:116
msgid ""
"Terminating a curses application is much easier than starting one. You'll "
"need to call::"
msgstr ""
"Terminar una aplicación de curses es mucho más fácil que iniciar una. "
"Tendrás que llamar a ::"

#: ../Doc/howto/curses.rst:123
msgid ""
"to reverse the curses-friendly terminal settings. Then call the :func:"
"`~curses.endwin` function to restore the terminal to its original operating "
"mode. ::"
msgstr ""
"para revertir la configuración de terminal amigable de curses. Llame luego a "
"la función :func:`~curses.endwin` para restaurar el terminal a su modo "
"operativo original. ::"

#: ../Doc/howto/curses.rst:129
msgid ""
"A common problem when debugging a curses application is to get your terminal "
"messed up when the application dies without restoring the terminal to its "
"previous state.  In Python this commonly happens when your code is buggy and "
"raises an uncaught exception.  Keys are no longer echoed to the screen when "
"you type them, for example, which makes using the shell difficult."
msgstr ""
"Un problema común al depurar una aplicación curses es hacer que su terminal "
"se estropee cuando la aplicación muere sin restaurar el terminal a su estado "
"anterior. En Python, esto ocurre comúnmente cuando su código tiene errores y "
"genera una excepción no detectada. Las teclas ya no se repiten en la "
"pantalla cuando las escribe, por ejemplo, lo que dificulta el uso del shell."

#: ../Doc/howto/curses.rst:135
msgid ""
"In Python you can avoid these complications and make debugging much easier "
"by importing the :func:`curses.wrapper` function and using it like this::"
msgstr ""
"En Python puede evitar estas complicaciones y facilitar la depuración "
"importando la función :func:`curses.wrapper` y usándola así::"

#: ../Doc/howto/curses.rst:154
#, fuzzy
msgid ""
"The :func:`~curses.wrapper` function takes a callable object and does the "
"initializations described above, also initializing colors if color support "
"is present.  :func:`!wrapper` then runs your provided callable. Once the "
"callable returns, :func:`!wrapper` will restore the original state of the "
"terminal.  The callable is called inside a :keyword:`try`...\\ :keyword:"
"`except` that catches exceptions, restores the state of the terminal, and "
"then re-raises the exception.  Therefore your terminal won't be left in a "
"funny state on exception and you'll be able to read the exception's message "
"and traceback."
msgstr ""
"La función :func:`~curses.wrapper` toma un objeto invocable y realiza las "
"inicializaciones descritas anteriormente, también inicializa los colores si "
"hay soporte de color. :func:`wrapper` luego ejecuta su invocable "
"proporcionado. Una vez que vuelve a llamarse, :func:`wrapper` restaurará el "
"estado original del terminal. El invocable se llama dentro de :keyword:`try`…"
"\\ :keyword:`except` que captura excepciones, restaura el estado del "
"terminal y luego vuelve a generar la excepción. Por lo tanto, su terminal no "
"se quedará en un estado extraño de excepción y podrá leer el mensaje de la "
"excepción y el rastreo."

#: ../Doc/howto/curses.rst:166
msgid "Windows and Pads"
msgstr "Ventanas y pads"

#: ../Doc/howto/curses.rst:168
msgid ""
"Windows are the basic abstraction in curses.  A window object represents a "
"rectangular area of the screen, and supports methods to display text, erase "
"it, allow the user to input strings, and so forth."
msgstr ""
"Las ventanas son la abstracción básica en curses. Un objeto de ventana "
"representa un área rectangular de la pantalla y admite métodos para mostrar "
"texto, borrarlo, permitir al usuario ingresar cadenas, etc."

#: ../Doc/howto/curses.rst:172
msgid ""
"The ``stdscr`` object returned by the :func:`~curses.initscr` function is a "
"window object that covers the entire screen.  Many programs may need only "
"this single window, but you might wish to divide the screen into smaller "
"windows, in order to redraw or clear them separately. The :func:`~curses."
"newwin` function creates a new window of a given size, returning the new "
"window object. ::"
msgstr ""
"El objeto ``stdscr`` retornado por la función :func:`~curses.initscr` es un "
"objeto de ventana que cubre toda la pantalla. Es posible que muchos "
"programas solo necesiten esta única ventana, pero es posible que desee "
"dividir la pantalla en ventanas más pequeñas para volver a dibujarlas o "
"borrarlas por separado. La función :func:`~curses.newwin` crea una nueva "
"ventana de un tamaño dado, retornando el nuevo objeto de ventana. ::"

#: ../Doc/howto/curses.rst:183
msgid ""
"Note that the coordinate system used in curses is unusual. Coordinates are "
"always passed in the order *y,x*, and the top-left corner of a window is "
"coordinate (0,0).  This breaks the normal convention for handling "
"coordinates where the *x* coordinate comes first.  This is an unfortunate "
"difference from most other computer applications, but it's been part of "
"curses since it was first written, and it's too late to change things now."
msgstr ""
"Tenga en cuenta que el sistema de coordenadas utilizado en curses es "
"inusual. Las coordenadas siempre se pasan en el orden *y,x*, y la esquina "
"superior izquierda de una ventana es la coordenada (0,0). Esto rompe la "
"convención normal para manejar coordenadas donde la coordenada *x* es lo "
"primero. Esta es una desafortunada diferencia de la mayoría de las otras "
"aplicaciones informáticas, pero ha sido parte de curses desde que se "
"escribió por primera vez, y ahora es demasiado tarde para cambiar las cosas."

#: ../Doc/howto/curses.rst:191
msgid ""
"Your application can determine the size of the screen by using the :data:"
"`curses.LINES` and :data:`curses.COLS` variables to obtain the *y* and *x* "
"sizes.  Legal coordinates will then extend from ``(0,0)`` to ``(curses.LINES "
"- 1, curses.COLS - 1)``."
msgstr ""
"Su aplicación puede determinar el tamaño de la pantalla utilizando las "
"variables :data:`curses.LINES` y :data:`curses.COLS` para obtener los "
"tamaños *y* y *x*. Las coordenadas legales se extenderán de ``(0,0)`` a "
"``(curses.LINES - 1, curses.COLS - 1)``."

#: ../Doc/howto/curses.rst:196
msgid ""
"When you call a method to display or erase text, the effect doesn't "
"immediately show up on the display.  Instead you must call the :meth:"
"`~curses.window.refresh` method of window objects to update the screen."
msgstr ""
"Cuando llama a un método para mostrar o borrar texto, el efecto no aparece "
"inmediatamente en la pantalla. En su lugar, debe llamar al método :meth:"
"`~curses.window.refresh` de los objetos de ventana para actualizar la "
"pantalla."

#: ../Doc/howto/curses.rst:201
#, fuzzy
msgid ""
"This is because curses was originally written with slow 300-baud terminal "
"connections in mind; with these terminals, minimizing the time required to "
"redraw the screen was very important.  Instead curses accumulates changes to "
"the screen and displays them in the most efficient manner when you call :"
"meth:`!refresh`.  For example, if your program displays some text in a "
"window and then clears the window, there's no need to send the original text "
"because they're never visible."
msgstr ""
"Esto se debe a que curses se escribieron originalmente teniendo en cuenta "
"las conexiones de terminales lentas de 300 baudios; con estos terminales, "
"era muy importante minimizar el tiempo requerido para volver a dibujar la "
"pantalla. En cambio, curses acumula cambios en la pantalla y los muestra de "
"la manera más eficiente cuando llama :meth:`refresh`. Por ejemplo, si su "
"programa muestra algo de texto en una ventana y luego borra la ventana, no "
"hay necesidad de enviar el texto original porque nunca son visibles."

#: ../Doc/howto/curses.rst:210
#, fuzzy
msgid ""
"In practice, explicitly telling curses to redraw a window doesn't really "
"complicate programming with curses much. Most programs go into a flurry of "
"activity, and then pause waiting for a keypress or some other action on the "
"part of the user.  All you have to do is to be sure that the screen has been "
"redrawn before pausing to wait for user input, by first calling :meth:`!"
"stdscr.refresh` or the :meth:`!refresh` method of some other relevant window."
msgstr ""
"En la práctica, decirle explícitamente a curses que vuelva a dibujar una "
"ventana no complica mucho la programación con curses. La mayoría de los "
"programas entran en una gran cantidad de actividad y luego se detienen a la "
"espera de que se presione una tecla u otra acción por parte del usuario. "
"Todo lo que tiene que hacer es asegurarse de que la pantalla se haya re-"
"dibujado antes de hacer una pausa para esperar la entrada del usuario, "
"llamando primero a ``stdscr.refresh()`` o al método :meth:`refresh` de "
"alguna otra ventana relevante."

#: ../Doc/howto/curses.rst:218
msgid ""
"A pad is a special case of a window; it can be larger than the actual "
"display screen, and only a portion of the pad displayed at a time. Creating "
"a pad requires the pad's height and width, while refreshing a pad requires "
"giving the coordinates of the on-screen area where a subsection of the pad "
"will be displayed.  ::"
msgstr ""
"Un pad es un caso especial de una ventana; puede ser más grande que la "
"pantalla de visualización real, y solo se muestra una parte del pad a la "
"vez. La creación de un pad requiere la altura y el ancho del pad, mientras "
"que la actualización de un pad requiere dar las coordenadas del área en "
"pantalla donde se mostrará una subsección del pad. ::"

#: ../Doc/howto/curses.rst:239
#, fuzzy
msgid ""
"The :meth:`!refresh` call displays a section of the pad in the rectangle "
"extending from coordinate (5,5) to coordinate (20,75) on the screen; the "
"upper left corner of the displayed section is coordinate (0,0) on the pad.  "
"Beyond that difference, pads are exactly like ordinary windows and support "
"the same methods."
msgstr ""
"La llamada :meth:`refresh` muestra una sección del pad en el rectángulo que "
"se extiende desde la coordenada (5,5) hasta la coordenada (20,75) en la "
"pantalla; la esquina superior izquierda de la sección mostrada es la "
"coordenada (0,0) en el pad. Más allá de esa diferencia, los pads son "
"exactamente como las ventanas normales y admiten los mismos métodos."

#: ../Doc/howto/curses.rst:245
#, fuzzy
msgid ""
"If you have multiple windows and pads on screen there is a more efficient "
"way to update the screen and prevent annoying screen flicker as each part of "
"the screen gets updated.  :meth:`!refresh` actually does two things:"
msgstr ""
"Si tiene varias ventanas y almohadillas en la pantalla, hay una manera más "
"eficiente de actualizar la pantalla y evitar el molesto parpadeo de la "
"pantalla a medida que se actualiza cada parte de la pantalla. :meth:"
"`refresh` en realidad hace dos cosas:"

#: ../Doc/howto/curses.rst:250
msgid ""
"Calls the :meth:`~curses.window.noutrefresh` method of each window to update "
"an underlying data structure representing the desired state of the screen."
msgstr ""
"Llama al método :meth:`~curses.window.noutrefresh` de cada ventana para "
"actualizar una estructura de datos subyacente que representa el estado "
"deseado de la pantalla."

#: ../Doc/howto/curses.rst:253
msgid ""
"Calls the function :func:`~curses.doupdate` function to change the physical "
"screen to match the desired state recorded in the data structure."
msgstr ""
"Llama a la función :func:`~curses.doupdate` para cambiar la pantalla física "
"para que coincida con el estado deseado registrado en la estructura de datos."

#: ../Doc/howto/curses.rst:256
#, fuzzy
msgid ""
"Instead you can call :meth:`!noutrefresh` on a number of windows to update "
"the data structure, and then call :func:`!doupdate` to update the screen."
msgstr ""
"En su lugar, puede llamar a :meth:`noutrefresh` en varias ventanas para "
"actualizar la estructura de datos, y luego llamar a :func:`doupdate` para "
"actualizar la pantalla."

#: ../Doc/howto/curses.rst:262
msgid "Displaying Text"
msgstr "Mostrando el texto"

#: ../Doc/howto/curses.rst:264
#, fuzzy
msgid ""
"From a C programmer's point of view, curses may sometimes look like a twisty "
"maze of functions, all subtly different.  For example, :c:func:`!addstr` "
"displays a string at the current cursor location in the ``stdscr`` window, "
"while :c:func:`!mvaddstr` moves to a given y,x coordinate first before "
"displaying the string. :c:func:`!waddstr` is just like :c:func:`!addstr`, "
"but allows specifying a window to use instead of using ``stdscr`` by "
"default. :c:func:`!mvwaddstr` allows specifying both a window and a "
"coordinate."
msgstr ""
"Desde el punto de vista de un programador en C, curses a veces puede parecer "
"un laberinto retorcido de funciones, todas sutilmente diferentes. Por "
"ejemplo, :c:func:`addtr` muestra una cadena en la ubicación actual del "
"cursor en la ventana ``stdscr``, mientras que :c:func:`mvaddstr` se mueve a "
"una determinada coordenada y, x primero antes de mostrar la cadena . :c:func:"
"`waddstr` es como :c:func:`addtr`, pero permite especificar una ventana para "
"usar en lugar de usar ``stdscr`` por defecto. :c:func:`mvwaddstr` permite "
"especificar tanto una ventana como una coordenada."

#: ../Doc/howto/curses.rst:273
msgid ""
"Fortunately the Python interface hides all these details.  ``stdscr`` is a "
"window object like any other, and methods such as :meth:`~curses.window."
"addstr` accept multiple argument forms.  Usually there are four different "
"forms."
msgstr ""
"Afortunadamente, la interfaz de Python oculta todos estos detalles. "
"``stdscr`` es un objeto de ventana como cualquier otro, y métodos como :meth:"
"`~curses.window.addstr` aceptan múltiples formas de argumento. Por lo "
"general, hay cuatro formas diferentes."

#: ../Doc/howto/curses.rst:279
msgid "Form"
msgstr "Formas"

#: ../Doc/howto/curses.rst:279 ../Doc/howto/curses.rst:347
msgid "Description"
msgstr "Descripción"

#: ../Doc/howto/curses.rst:281
msgid "*str* or *ch*"
msgstr "*str* o *ch*"

#: ../Doc/howto/curses.rst:281
msgid "Display the string *str* or character *ch* at the current position"
msgstr "Mostrar la cadena *str* o el carácter *ch* en la posición actual"

#: ../Doc/howto/curses.rst:284
msgid "*str* or *ch*, *attr*"
msgstr "*str* o *ch*, *attr*"

#: ../Doc/howto/curses.rst:284
msgid ""
"Display the string *str* or character *ch*, using attribute *attr* at the "
"current position"
msgstr ""
"Muestra la cadena *str* o el carácter *ch*, utilizando el atributo *attr* en "
"la posición actual"

#: ../Doc/howto/curses.rst:288
msgid "*y*, *x*, *str* or *ch*"
msgstr "*y*, *x*, *str* o *ch*"

#: ../Doc/howto/curses.rst:288
msgid "Move to position *y,x* within the window, and display *str* or *ch*"
msgstr ""
"Moverse a la posición *y,x* dentro de la ventana, y mostrar *st* o *ch*"

#: ../Doc/howto/curses.rst:291
msgid "*y*, *x*, *str* or *ch*, *attr*"
msgstr "*y*, *x*, *str* o *ch*, *attr*"

#: ../Doc/howto/curses.rst:291
msgid ""
"Move to position *y,x* within the window, and display *str* or *ch*, using "
"attribute *attr*"
msgstr ""
"Muévase a la posición *y, x* dentro de la ventana y muestre *str* o *ch*, "
"usando el atributo *attr*"

#: ../Doc/howto/curses.rst:295
msgid ""
"Attributes allow displaying text in highlighted forms such as boldface, "
"underline, reverse code, or in color.  They'll be explained in more detail "
"in the next subsection."
msgstr ""
"Los atributos permiten mostrar texto en formas resaltadas como negrita, "
"subrayado, código inverso o en color. Se explicarán con más detalle en la "
"siguiente subsección."

#: ../Doc/howto/curses.rst:300
#, fuzzy
msgid ""
"The :meth:`~curses.window.addstr` method takes a Python string or bytestring "
"as the value to be displayed.  The contents of bytestrings are sent to the "
"terminal as-is.  Strings are encoded to bytes using the value of the "
"window's :attr:`~window.encoding` attribute; this defaults to the default "
"system encoding as returned by :func:`locale.getencoding`."
msgstr ""
"El método :meth:`~curses.window.addstr` toma una cadena de texto en Python "
"como valor para mostrar en pantalla. Los contenidos de las cadenas de texto "
"en bytes son enviados directamente al terminal. Las cadenas de texto son "
"codificadas en bytes utilizando el valor del atributo :attr:`encoding` de la "
"ventana; por defecto esto utiliza la codificación del sistema como lo "
"devuelve la función :func:`locale.getencoding`."

#: ../Doc/howto/curses.rst:306
msgid ""
"The :meth:`~curses.window.addch` methods take a character, which can be "
"either a string of length 1, a bytestring of length 1, or an integer."
msgstr ""
"Los métodos :meth:`~curses.window.addch` toman un carácter, que puede ser "
"una cadena de longitud 1, una cadena de bytes de longitud 1 o un entero."

#: ../Doc/howto/curses.rst:309
msgid ""
"Constants are provided for extension characters; these constants are "
"integers greater than 255.  For example, :const:`ACS_PLMINUS` is a +/- "
"symbol, and :const:`ACS_ULCORNER` is the upper left corner of a box (handy "
"for drawing borders).  You can also use the appropriate Unicode character."
msgstr ""
"Se proporcionan constantes para los caracteres de extensión; estas "
"constantes son enteros mayores que 255. Por ejemplo :const:`ACS_PLMINUS` es "
"un símbolo +/-, y :const:`ACS_ULCORNER` es la esquina superior izquierda de "
"un cuadro (útil para dibujar bordes). También puede usar el carácter Unicode "
"apropiado."

#: ../Doc/howto/curses.rst:315
msgid ""
"Windows remember where the cursor was left after the last operation, so if "
"you leave out the *y,x* coordinates, the string or character will be "
"displayed wherever the last operation left off.  You can also move the "
"cursor with the ``move(y,x)`` method.  Because some terminals always display "
"a flashing cursor, you may want to ensure that the cursor is positioned in "
"some location where it won't be distracting; it can be confusing to have the "
"cursor blinking at some apparently random location."
msgstr ""
"Windows recuerda dónde se dejó el cursor después de la última operación, por "
"lo que si deja de lado las coordenadas *y, x*, la cadena o el carácter se "
"mostrarán donde se haya quedado la última operación. También puede mover el "
"cursor con el método ``move(y, x)``. Debido a que algunos terminales siempre "
"muestran un cursor parpadeante, es posible que desee asegurarse de que el "
"cursor esté ubicado en algún lugar donde no distraiga; Puede ser confuso "
"tener el cursor parpadeando en alguna ubicación aparentemente aleatoria."

#: ../Doc/howto/curses.rst:323
msgid ""
"If your application doesn't need a blinking cursor at all, you can call "
"``curs_set(False)`` to make it invisible.  For compatibility with older "
"curses versions, there's a ``leaveok(bool)`` function that's a synonym for :"
"func:`~curses.curs_set`.  When *bool* is true, the curses library will "
"attempt to suppress the flashing cursor, and you won't need to worry about "
"leaving it in odd locations."
msgstr ""
"Si su aplicación no necesita un cursor parpadeante, puede llamar a "
"``curs_set (False)`` para hacerla invisible. Para compatibilidad con "
"versiones anteriores de curses, hay una función ``jeaveok (bool)`` que es "
"sinónimo de :func:`~curses.curs_set`. Cuando *bool* es verdadero, la "
"biblioteca curses intentará suprimir el cursor parpadeante, y no tendrá que "
"preocuparse por dejarlo en ubicaciones extrañas."

#: ../Doc/howto/curses.rst:332
msgid "Attributes and Color"
msgstr "Atributos y color"

#: ../Doc/howto/curses.rst:334
msgid ""
"Characters can be displayed in different ways.  Status lines in a text-based "
"application are commonly shown in reverse video, or a text viewer may need "
"to highlight certain words.  curses supports this by allowing you to specify "
"an attribute for each cell on the screen."
msgstr ""
"Los caracteres se pueden mostrar de diferentes maneras. Las líneas de estado "
"en una aplicación basada en texto se muestran comúnmente en video inverso, o "
"un visor de texto puede necesitar resaltar ciertas palabras. curses admite "
"esto al permitirle especificar un atributo para cada celda en la pantalla."

#: ../Doc/howto/curses.rst:339
msgid ""
"An attribute is an integer, each bit representing a different attribute.  "
"You can try to display text with multiple attribute bits set, but curses "
"doesn't guarantee that all the possible combinations are available, or that "
"they're all visually distinct.  That depends on the ability of the terminal "
"being used, so it's safest to stick to the most commonly available "
"attributes, listed here."
msgstr ""
"Un atributo es un entero, cada bit representa un atributo diferente. Puede "
"intentar mostrar texto con múltiples conjuntos de bits de atributos, pero "
"curses no garantizan que todas las combinaciones posibles estén disponibles, "
"o que todas sean visualmente distintas. Eso depende de la capacidad del "
"terminal que se utilice, por lo que es más seguro apegarse a los atributos "
"más comúnmente disponibles, enumerados aquí."

#: ../Doc/howto/curses.rst:347
msgid "Attribute"
msgstr "Atributo"

#: ../Doc/howto/curses.rst:349
msgid ":const:`A_BLINK`"
msgstr ":const:`A_BLINK`"

#: ../Doc/howto/curses.rst:349
msgid "Blinking text"
msgstr "Texto parpadeante"

#: ../Doc/howto/curses.rst:351
msgid ":const:`A_BOLD`"
msgstr ":const:`A_BOLD`"

#: ../Doc/howto/curses.rst:351
msgid "Extra bright or bold text"
msgstr "Texto extra brillante o en negrita"

#: ../Doc/howto/curses.rst:353
msgid ":const:`A_DIM`"
msgstr ":const:`A_DIM`"

#: ../Doc/howto/curses.rst:353
msgid "Half bright text"
msgstr "Texto medio brillante"

#: ../Doc/howto/curses.rst:355
msgid ":const:`A_REVERSE`"
msgstr ":const:`A_REVERSE`"

#: ../Doc/howto/curses.rst:355
msgid "Reverse-video text"
msgstr "Texto de video inverso"

#: ../Doc/howto/curses.rst:357
msgid ":const:`A_STANDOUT`"
msgstr ":const:`A_STANDOUT`"

#: ../Doc/howto/curses.rst:357
msgid "The best highlighting mode available"
msgstr "El mejor modo de resaltado disponible"

#: ../Doc/howto/curses.rst:359
msgid ":const:`A_UNDERLINE`"
msgstr ":const:`A_UNDERLINE`"

#: ../Doc/howto/curses.rst:359
msgid "Underlined text"
msgstr "Texto subrayado"

#: ../Doc/howto/curses.rst:362
msgid ""
"So, to display a reverse-video status line on the top line of the screen, "
"you could code::"
msgstr ""
"Entonces, para mostrar una línea de estado de video inverso en la línea "
"superior de la pantalla, puede codificar::"

#: ../Doc/howto/curses.rst:369
msgid ""
"The curses library also supports color on those terminals that provide it. "
"The most common such terminal is probably the Linux console, followed by "
"color xterms."
msgstr ""
"La biblioteca curses también admite color en los terminales que lo "
"proporcionen. El terminal más común es probablemente la consola de Linux, "
"seguido de *xterms* en color."

#: ../Doc/howto/curses.rst:373
msgid ""
"To use color, you must call the :func:`~curses.start_color` function soon "
"after calling :func:`~curses.initscr`, to initialize the default color set "
"(the :func:`curses.wrapper` function does this automatically).  Once that's "
"done, the :func:`~curses.has_colors` function returns TRUE if the terminal "
"in use can actually display color.  (Note: curses uses the American spelling "
"'color', instead of the Canadian/British spelling 'colour'.  If you're used "
"to the British spelling, you'll have to resign yourself to misspelling it "
"for the sake of these functions.)"
msgstr ""
"Para usar el color, debe llamar a la función :func:`~curses.start_color` "
"poco después de llamar :func:`~curses.initscr`, para inicializar el conjunto "
"de colores predeterminado (la función :func:`curses.wrapper` hace esto "
"automáticamente). Una vez hecho esto, la función :func:`~curses.has_colors` "
"retorna TRUE si el terminal en uso realmente puede mostrar color. (Nota: "
"curses usa el ‘color’ de la ortografía estadounidense, en lugar del ‘color’ "
"de la ortografía canadiense/británica. Si está acostumbrado a la ortografía "
"británica, tendrá que resignarse a escribir mal por el bien de estas "
"funciones. )"

#: ../Doc/howto/curses.rst:383
msgid ""
"The curses library maintains a finite number of color pairs, containing a "
"foreground (or text) color and a background color.  You can get the "
"attribute value corresponding to a color pair with the :func:`~curses."
"color_pair` function; this can be bitwise-OR'ed with other attributes such "
"as :const:`A_REVERSE`, but again, such combinations are not guaranteed to "
"work on all terminals."
msgstr ""
"La biblioteca curses mantiene un número finito de pares de colores, que "
"contienen un color de primer plano (o texto) y un color de fondo. Puede "
"obtener el valor del atributo correspondiente a un par de colores con la "
"función :func:`~curses.color_pair`; esto puede ser operado bit a bit con "
"otros atributos como :const:`A_REVERSE`, pero nuevamente, no se garantiza "
"que tales combinaciones funcionen en todos los terminales."

#: ../Doc/howto/curses.rst:390
msgid "An example, which displays a line of text using color pair 1::"
msgstr ""
"Un ejemplo, que muestra una línea de texto usando el par de colores 1 ::"

#: ../Doc/howto/curses.rst:395
msgid ""
"As I said before, a color pair consists of a foreground and background "
"color. The ``init_pair(n, f, b)`` function changes the definition of color "
"pair *n*, to foreground color f and background color b.  Color pair 0 is "
"hard-wired to white on black, and cannot be changed."
msgstr ""
"Como dije antes, un par de colores consiste en un color de primer plano y de "
"fondo. La función ``init_pair (n, f, b)`` cambia la definición del par de "
"colores *n*, a color de primer plano f y color de fondo b. El par de colores "
"0 está cableado a blanco sobre negro, y no se puede cambiar."

#: ../Doc/howto/curses.rst:400
msgid ""
"Colors are numbered, and :func:`start_color` initializes 8 basic colors when "
"it activates color mode.  They are: 0:black, 1:red, 2:green, 3:yellow, 4:"
"blue, 5:magenta, 6:cyan, and 7:white.  The :mod:`curses` module defines "
"named constants for each of these colors: :const:`curses.COLOR_BLACK`, :"
"const:`curses.COLOR_RED`, and so forth."
msgstr ""
"Los colores están numerados y :func:`start_color` inicializa 8 colores "
"básicos cuando activa el modo de color. Son: 0:negro, 1:rojo, 2:verde, 3:"
"amarillo, 4:azul, 5:magenta, 6:cian y 7:blanco. El módulo :mod:`curses` "
"define constantes con nombre para cada uno de estos colores: :const:`curses."
"COLOR_BLACK`, :const:`curses.COLOR_RED`, y así sucesivamente."

#: ../Doc/howto/curses.rst:406
msgid ""
"Let's put all this together. To change color 1 to red text on a white "
"background, you would call::"
msgstr ""
"Pongamos todo esto juntos. Para cambiar el color 1 al texto rojo sobre un "
"fondo blanco, debe llamar a::"

#: ../Doc/howto/curses.rst:411
msgid ""
"When you change a color pair, any text already displayed using that color "
"pair will change to the new colors.  You can also display new text in this "
"color with::"
msgstr ""
"Cuando cambia un par de colores, cualquier texto que ya se muestre usando "
"ese par de colores cambiará a los nuevos colores. También puede mostrar "
"texto nuevo en este color con::"

#: ../Doc/howto/curses.rst:417
msgid ""
"Very fancy terminals can change the definitions of the actual colors to a "
"given RGB value.  This lets you change color 1, which is usually red, to "
"purple or blue or any other color you like.  Unfortunately, the Linux "
"console doesn't support this, so I'm unable to try it out, and can't provide "
"any examples.  You can check if your terminal can do this by calling :func:"
"`~curses.can_change_color`, which returns ``True`` if the capability is "
"there.  If you're lucky enough to have such a talented terminal, consult "
"your system's man pages for more information."
msgstr ""
"Los terminales muy elegantes pueden cambiar las definiciones de los colores "
"reales a un valor RGB dado. Esto le permite cambiar el color 1, que "
"generalmente es rojo, a púrpura o azul o cualquier otro color que desee. "
"Desafortunadamente, la consola de Linux no admite esto, por lo que no puedo "
"probarlo y no puedo proporcionar ningún ejemplo. Puede verificar si su "
"terminal puede hacer esto llamando a :func:`~curses.can_change_color`, que "
"retorna ``Verdadero`` si la capacidad está ahí. Si tiene la suerte de tener "
"un terminal tan talentoso, consulte las páginas de manual de su sistema para "
"obtener más información."

#: ../Doc/howto/curses.rst:428
msgid "User Input"
msgstr "*Input* del usuario"

#: ../Doc/howto/curses.rst:430
msgid ""
"The C curses library offers only very simple input mechanisms. Python's :mod:"
"`curses` module adds a basic text-input widget.  (Other libraries such as "
"`Urwid <https://pypi.org/project/urwid/>`_ have more extensive collections "
"of widgets.)"
msgstr ""
"La biblioteca C curses ofrece solo mecanismos de entrada muy simples. El "
"módulo Python :mod:`curses` agrega un widget básico de entrada de texto. "
"(Otras bibliotecas como `Urwid <https://pypi.org/project/urwid/>`_ tienen "
"colecciones más extensas de widgets)."

#: ../Doc/howto/curses.rst:435
msgid "There are two methods for getting input from a window:"
msgstr "Hay dos métodos para obtener información desde una ventana:"

#: ../Doc/howto/curses.rst:437
msgid ""
":meth:`~curses.window.getch` refreshes the screen and then waits for the "
"user to hit a key, displaying the key if :func:`~curses.echo` has been "
"called earlier.  You can optionally specify a coordinate to which the cursor "
"should be moved before pausing."
msgstr ""
":meth:`~curses.window.getch` actualiza la pantalla y luego espera a que el "
"usuario presione una tecla, mostrando la tecla si :func:`~curses.echo` ha "
"sido llamado anteriormente. Opcionalmente, puede especificar una coordenada "
"a la que se debe mover el cursor antes de pausar."

#: ../Doc/howto/curses.rst:442
msgid ""
":meth:`~curses.window.getkey` does the same thing but converts the integer "
"to a string.  Individual characters are returned as 1-character strings, and "
"special keys such as function keys return longer strings containing a key "
"name such as ``KEY_UP`` or ``^G``."
msgstr ""
":meth:`~curses.window.getkey` hace lo mismo pero convierte el entero en una "
"cadena. Los caracteres individuales se retornan como cadenas de 1 carácter, "
"y las teclas especiales como las teclas de función retornan cadenas más "
"largas que contienen un nombre de tecla como ``KEY_UP`` o ``^ G``."

#: ../Doc/howto/curses.rst:447
#, fuzzy
msgid ""
"It's possible to not wait for the user using the :meth:`~curses.window."
"nodelay` window method. After ``nodelay(True)``, :meth:`!getch` and :meth:`!"
"getkey` for the window become non-blocking. To signal that no input is "
"ready, :meth:`!getch` returns ``curses.ERR`` (a value of -1) and :meth:`!"
"getkey` raises an exception. There's also a :func:`~curses.halfdelay` "
"function, which can be used to (in effect) set a timer on each :meth:`!"
"getch`; if no input becomes available within a specified delay (measured in "
"tenths of a second), curses raises an exception."
msgstr ""
"Es posible no esperar al usuario utilizando el método de ventana :meth:`~ "
"curses.window.nodelay`. Después de ``nodelay(True)``, :meth:`getch` y :meth:"
"`getkey` para que la ventana no se bloquee. Para indicar que no hay ninguna "
"entrada lista, :meth:`getch` retorna ``curses.ERR`` (un valor de -1) y :meth:"
"`getkey` genera una excepción. También hay una función :func:`~curses."
"halfdelay`, que se puede usar para (en efecto) establecer un temporizador en "
"cada :meth:`getch`; Si no hay entrada disponible dentro de un retraso "
"especificado (medido en décimas de segundo), curses generan una excepción."

#: ../Doc/howto/curses.rst:457
#, fuzzy
msgid ""
"The :meth:`!getch` method returns an integer; if it's between 0 and 255, it "
"represents the ASCII code of the key pressed.  Values greater than 255 are "
"special keys such as Page Up, Home, or the cursor keys. You can compare the "
"value returned to constants such as :const:`curses.KEY_PPAGE`, :const:"
"`curses.KEY_HOME`, or :const:`curses.KEY_LEFT`.  The main loop of your "
"program may look something like this::"
msgstr ""
"El método :meth:`getch` retorna un entero; si está entre 0 y 255, representa "
"el código ASCII de la tecla presionada. Los valores superiores a 255 son "
"teclas especiales como Re Pág, Inicio o las teclas del cursor. Puede "
"comparar el valor retornado a constantes como :const:`curses.KEY_PPAGE`, :"
"const:`curses.KEY_HOME`, o :const:`curses.KEY_LEFT`. El bucle principal de "
"su programa puede verse así::"

#: ../Doc/howto/curses.rst:473
msgid ""
"The :mod:`curses.ascii` module supplies ASCII class membership functions "
"that take either integer or 1-character string arguments; these may be "
"useful in writing more readable tests for such loops.  It also supplies "
"conversion functions  that take either integer or 1-character-string "
"arguments and return the same type.  For example, :func:`curses.ascii.ctrl` "
"returns the control character corresponding to its argument."
msgstr ""
"El módulo :mod:`curses.ascii` proporciona funciones de membresía de clase "
"ASCII que toman argumentos de cadena de entero o de 1 carácter; Estos pueden "
"ser útiles para escribir pruebas más legibles para dichos bucles. También "
"proporciona funciones de conversión que toman argumentos enteros o de cadena "
"de 1 carácter y retornen el mismo tipo. Por ejemplo, :func:`curses.ascii."
"ctrl` retorna el carácter de control correspondiente a su argumento."

#: ../Doc/howto/curses.rst:480
msgid ""
"There's also a method to retrieve an entire string, :meth:`~curses.window."
"getstr`.  It isn't used very often, because its functionality is quite "
"limited; the only editing keys available are the backspace key and the Enter "
"key, which terminates the string.  It can optionally be limited to a fixed "
"number of characters. ::"
msgstr ""
"También hay un método para recuperar una cadena completa, :meth:`~curses."
"window.getstr`. No se usa con mucha frecuencia, porque su funcionalidad es "
"bastante limitada; Las únicas teclas de edición disponibles son la tecla de "
"retroceso y la tecla Intro, que termina la cadena. Opcionalmente, puede "
"limitarse a un número fijo de caracteres. ::"

#: ../Doc/howto/curses.rst:491
msgid ""
"The :mod:`curses.textpad` module supplies a text box that supports an Emacs-"
"like set of keybindings.  Various methods of the :class:`~curses.textpad."
"Textbox` class support editing with input validation and gathering the edit "
"results either with or without trailing spaces.  Here's an example::"
msgstr ""
"El módulo :mod:`curses.textpad` proporciona un cuadro de texto que admite un "
"conjunto de teclas tipo Emacs. Varios métodos de la clase :class:`~curses."
"textpad.Textbox` admiten la edición con validación de entrada y recopilan "
"los resultados de edición con o sin espacios finales. Aquí hay un ejemplo::"

#: ../Doc/howto/curses.rst:515
msgid ""
"See the library documentation on :mod:`curses.textpad` for more details."
msgstr ""
"Consulte la documentación de la biblioteca sobre :mod:`curses.textpad` para "
"más detalles."

#: ../Doc/howto/curses.rst:519
msgid "For More Information"
msgstr "Para más información"

#: ../Doc/howto/curses.rst:521
msgid ""
"This HOWTO doesn't cover some advanced topics, such as reading the contents "
"of the screen or capturing mouse events from an xterm instance, but the "
"Python library page for the :mod:`curses` module is now reasonably "
"complete.  You should browse it next."
msgstr ""
"Este CÓMO no cubre algunos temas avanzados, como leer el contenido de la "
"pantalla o capturar eventos del mouse desde una instancia de xterm, pero la "
"página de la biblioteca de Python para el módulo :mod:`curses` ahora está "
"razonablemente completa. Deberías buscarlo posteriormente."

#: ../Doc/howto/curses.rst:526
#, fuzzy
msgid ""
"If you're in doubt about the detailed behavior of the curses functions, "
"consult the manual pages for your curses implementation, whether it's "
"ncurses or a proprietary Unix vendor's.  The manual pages will document any "
"quirks, and provide complete lists of all the functions, attributes, and :"
"ref:`ACS_\\* <curses-acs-codes>` characters available to you."
msgstr ""
"Si tiene dudas sobre el comportamiento detallado de las funciones de curses, "
"consulte las páginas del manual para su implementación de curses, ya sea "
"ncurses o un proveedor exclusivo de Unix. Las páginas del manual "
"documentarán cualquier peculiaridad y proporcionarán listas completas de "
"todas las funciones, atributos y caracteres :const:`ACS_\\*` disponibles "
"para usted."

#: ../Doc/howto/curses.rst:533
msgid ""
"Because the curses API is so large, some functions aren't supported in the "
"Python interface.  Often this isn't because they're difficult to implement, "
"but because no one has needed them yet.  Also, Python doesn't yet support "
"the menu library associated with ncurses. Patches adding support for these "
"would be welcome; see `the Python Developer's Guide <https://devguide.python."
"org/>`_ to learn more about submitting patches to Python."
msgstr ""
"Debido a que la API de curses es tan grande, algunas funciones no son "
"compatibles con la interfaz de Python. A menudo, esto no se debe a que sean "
"difíciles de implementar, sino a que nadie los ha necesitado todavía. "
"Además, Python aún no admite la biblioteca de menús asociada con ncurses. "
"Los parches que agregan soporte para estos serían bienvenidos; consulte `la "
"Guía del desarrollador de Python <https://devguide.python.org/>`_ para "
"obtener más información sobre cómo enviar parches a Python."

#: ../Doc/howto/curses.rst:541
msgid ""
"`Writing Programs with NCURSES <https://invisible-island.net/ncurses/ncurses-"
"intro.html>`_: a lengthy tutorial for C programmers."
msgstr ""
"`Escribir programas con NCURSES <https://invisible-island.net/ncurses/"
"ncurses-intro.html>`_: un tutorial extenso para programadores en C."

#: ../Doc/howto/curses.rst:543
msgid "`The ncurses man page <https://linux.die.net/man/3/ncurses>`_"
msgstr ""
"`La página web con el manual de  ncurses <https://linux.die.net/man/3/"
"ncurses>`_"

#: ../Doc/howto/curses.rst:544
msgid ""
"`The ncurses FAQ <https://invisible-island.net/ncurses/ncurses.faq.html>`_"
msgstr ""
"`Preguntas y respuestas frecuentes de ncurses <http://invisible-island.net/"
"ncurses/ncurses.faq.html>`_"

#: ../Doc/howto/curses.rst:545
msgid ""
"`\"Use curses... don't swear\" <https://www.youtube.com/watch?"
"v=eN1eZtjLEnU>`_: video of a PyCon 2013 talk on controlling terminals using "
"curses or Urwid."
msgstr ""
"`\"Use curses… don’t swear\" <https://www.youtube.com/watch?"
"v=eN1eZtjLEnU>`_: video de una charla de PyCon 2013 sobre el control de "
"terminales usando curses o Urwid."

#: ../Doc/howto/curses.rst:547
msgid ""
"`\"Console Applications with Urwid\" <https://pyvideo.org/video/1568/console-"
"applications-with-urwid>`_: video of a PyCon CA 2012 talk demonstrating some "
"applications written using Urwid."
msgstr ""
"`\"Console Applications with Urwid\" <https://www.pyvideo.org/video/1568/"
"console-applications-with-urwid>`_: video de una charla en PyCon CA 2012 que "
"muestra algunas aplicaciones escritas usando Urwid."