Basta ya de indagar en otras páginas ya que estás al lugar exacto, contamos con la solución que quieres hallar sin complicaciones.
Solución:
Hay varios escenarios diferentes; Describiré los más comunes. Los sucesivos eventos macroscópicos son:
- Entrada: el evento de pulsación de tecla se transmite desde el hardware del teclado a la aplicación.
- Procesamiento: la aplicación decide que porque la clave A fue presionado, debe mostrar el carácter
a. - Salida: la aplicación da la orden de mostrar
aen la pantalla.
Aplicaciones GUI
La interfaz gráfica de usuario estándar de facto de los sistemas Unix es el sistema X Window, a menudo llamado X11 porque se estabilizó en la undécima versión de su protocolo central entre las aplicaciones y el servidor de visualización. Un programa llamado servidor X se encuentra entre el kernel del sistema operativo y las aplicaciones; proporciona servicios que incluyen mostrar ventanas en la pantalla y transmitir las pulsaciones de teclas a la ventana que tiene el foco.
Aporte
+----------+ +-------------+ +-----+
| keyboard |------------->| motherboard |-------->| CPU |
+----------+ +-------------+ +-----+
USB, PS/2, … PCI, …
key down/up
Primero, la información sobre la pulsación y liberación de teclas se transmite desde el teclado a la computadora y dentro de la computadora. Los detalles dependen del tipo de hardware. No me extenderé más en esta parte porque la información sigue siendo la misma en toda esta parte de la cadena: se presionó o soltó una determinada tecla.
+--------+ +----------+ +-------------+
-------->| kernel |------->| X server |--------->| application |
+--------+ +----------+ +-------------+
interrupt scancode keysym
=keycode +modifiers
Cuando ocurre un evento de hardware, la CPU desencadena una interrupción, lo que hace que se ejecute algún código en el kernel. Este código detecta que el evento de hardware es una pulsación de tecla o liberación de tecla procedente de un teclado y registra la escanear código que identifica la clave.
El servidor X lee los eventos de entrada a través de un archivo de dispositivo, por ejemplo /dev/input/eventNNN en Linux (donde NNN es un número). Siempre que hay un evento, el kernel indica que hay datos para leer desde ese dispositivo. El archivo de dispositivo transmite eventos clave arriba / abajo con un código de escaneo, que puede o no ser idéntico al valor transmitido por el hardware (el kernel puede traducir el código de escaneo de un valor dependiente del teclado a un valor común, y Linux no lo hace). no retransmita los códigos de escaneo que no conoce).
X llama al código de escaneo que lee un clave. El servidor X mantiene una tabla que traduce los códigos clave en keysyms (abreviatura de “símbolo de llave”). Los códigos clave son numéricos, mientras que los claves son nombres como A, aacute, F1, KP_Add, Control_L,… El símbolo de la tecla puede diferir según las teclas modificadoras que se presionen (Cambio, control,…).
Hay dos mecanismos para configurar el mapeo de los códigos de teclas a los símbolos de las teclas:
- xmodmap es el mecanismo tradicional. Es una tabla simple que mapea códigos de teclas a una lista de símbolos de teclas (sin modificar, desplazados,…).
- XKB es un mecanismo más poderoso, pero más complejo, con mejor soporte para más modificadores, en particular para la configuración de dos idiomas, entre otros.
Las aplicaciones se conectan al servidor X y reciben una notificación cuando se presiona una tecla mientras una ventana de esa aplicación tiene el foco. La notificación indica que se presionó o soltó un cierto keyym, así como qué modificadores están presionados actualmente. Puede ver los símbolos de las claves ejecutando el programa xev desde una terminal. Lo que la aplicación haga con la información depende de ella; algunas aplicaciones tienen combinaciones de teclas configurables.
En una configuración típica, cuando presiona la tecla etiquetada A sin modificadores, esto envía el keyym a a la aplicación; si la aplicación está en un modo en el que está escribiendo texto, esto inserta el carácter a.
La relación entre la distribución del teclado y xmodmap entra en más detalles sobre la entrada del teclado. ¿Cómo funcionan los eventos del mouse en linux? ofrece una descripción general de la entrada del mouse en los niveles inferiores.
Producción
+-------------+ +----------+ +-----+ +---------+
| application |------->| X server |---····-->| GPU |-------->| monitor |
+-------------+ +----------+ +-----+ +---------+
text or varies VGA, DVI,
image HDMI, …
Hay dos formas de mostrar un carácter.
- Representación del lado del servidor: la aplicación le dice al servidor X “dibuje esta cadena en esta fuente en esta posición”. La fuente reside en el servidor X.
- Representación del lado del cliente: la aplicación crea una imagen que representa el carácter en una fuente que elige, luego le dice al servidor X que muestre esa imagen.
Consulte ¿Cuáles son los propósitos de los diferentes tipos de fuentes XWindows? para una discusión de la representación de texto del lado del cliente y del lado del servidor bajo X11.
Lo que sucede entre el servidor X y la unidad de procesamiento de gráficos (el procesador en la tarjeta de video) depende en gran medida del hardware. Los sistemas simples tienen el servidor X en una región de memoria llamada framebuffer, que la GPU recoge para mostrar. Los sistemas avanzados, como los que se encuentran en cualquier PC o teléfono inteligente del siglo XXI, permiten que la GPU realice algunas operaciones directamente para un mejor rendimiento. En última instancia, la GPU transmite el contenido de la pantalla píxel a píxel cada fracción de segundo al monitor.
Aplicación en modo texto, que se ejecuta en una terminal.
Si su editor de texto es una aplicación en modo texto que se ejecuta en un terminal, entonces el terminal es la aplicación para el propósito de la sección anterior. En esta sección, explico la interfaz entre la aplicación en modo texto y el terminal. Primero describo el caso de un emulador de terminal que se ejecuta bajo X11. ¿Cuál es la diferencia exacta entre un ‘terminal’, un ‘shell’, un ‘tty’ y una ‘consola’? puede ser un fondo útil aquí. Después de leer esto, es posible que desee leer el mucho más detallado ¿Cuáles son las responsabilidades de cada componente de Pseudo-Terminal (PTY) (software, lado maestro, lado esclavo)?
Aporte
+-------------------+ +-------------+
----->| terminal emulator |-------------->| application |
+-------------------+ +-------------+
keysym character or
escape sequence
El emulador de terminal recibe eventos como “Left fue presionado mientras Shift Estaba abajo”. La interfaz entre el emulador de terminal y la aplicación en modo texto es una pseudo-terminal (pty), un dispositivo de caracteres que transmite bytes. Cuando el emulador de terminal recibe un evento de pulsación de tecla, lo transforma en uno o más bytes que la aplicación puede leer desde el dispositivo pty.
Los caracteres imprimibles fuera del rango ASCII se transmiten como uno o más bytes según el carácter y la codificación. Por ejemplo, en la codificación UTF-8 del juego de caracteres Unicode, los caracteres en el rango ASCII se codifican como un solo byte, mientras que los caracteres fuera de ese rango se codifican como varios bytes.
Pulsaciones de teclas que corresponden a una tecla de función o un carácter imprimible con modificadores como control o Alt se envían como un secuencia de escape. Las secuencias de escape suelen constar del carácter de escape (valor de byte 27 = 0x1B = 33, a veces representado como ^[ or e) followed by one or more printable characters. A few keys or key combination have a control character corresponding to them in ASCII-based encodings (which is pretty much all of them in use today, including Unicode): Ctrl+letter yields a character value in the range 1–26, Esc is the escape character seen above and is also the same as Ctrl+[, Tab is the same as Ctrl+I, Return is the same as Ctrl+M, etc.
Different terminals send different escape sequences for a given key or key combination. Fortunately, the converse is not true: given a sequence, there is in practice at most one key combination that it encodes. The one exception is the character 127 = 0x7f = 177 which is often Backspace but sometimes Delete.
In a terminal, if you type Ctrl+V followed by a key combination, this inserts the first byte of the escape sequence from the key combination literally. Since escape sequences normally consist only of printable characters after the first one, this inserts the whole escape sequence literally. See key bindings table? for a discussion of zsh in this context.
The terminal may transmit the same escape sequence for some modifier combinations (e.g. many terminals transmit a space character for both Space and Shift+Space; xterm has a mode to distinguish modifier combinations but terminals based on the popular vte library don’t). A few keys are not transmitted at all, for example modifier keys or keys that trigger a binding of the terminal emulator (e.g. a copy or paste command).
It is up to the application to translate escape sequences into symbolic key names if it so desires.
Output
+-------------+ +-------------------+
| application |-------------->| terminal emulator |--->
+-------------+ +-------------------+
character or
escape sequence
Output is rather simpler than input. If the application outputs a character to the pty device file, the terminal emulator displays it at the current cursor position. (The terminal emulator maintains a cursor position, and scrolls if the cursor would fall under the bottom of the screen.) The application can also output escape sequences (mostly beginning with ^[ or ^]) para indicarle al terminal que realice acciones como mover el cursor, cambiar los atributos del texto (color, negrita,…) o borrar parte de la pantalla.
Las secuencias de escape admitidas por el emulador de terminal se describen en la base de datos termcap o terminfo. La mayoría de los emuladores de terminal de hoy en día están bastante alineados con xterm. ¿Ver la documentación sobre las variables LESS_TERMCAP_ *? para una discusión más larga de las bases de datos de información de capacidad de la terminal, y Cómo evitar que el cursor parpadee y ¿Puedo configurar los colores de la terminal de mi máquina local para usar los de la máquina en la que estoy conectado? para ver algunos ejemplos de uso.
Aplicación que se ejecuta en una consola de texto
Si la aplicación se ejecuta directamente en una consola de texto, es decir, una terminal proporcionada por el kernel en lugar de una aplicación de emulador de terminal, se aplican los mismos principios. La interfaz entre el terminal y la aplicación sigue siendo un flujo de bytes que transmite caracteres, con teclas especiales y comandos codificados como secuencias de escape.
Aplicación remota, a la que se accede a través de la red
Aplicación de texto remoto
Si ejecuta un programa en una máquina remota, por ejemplo, a través de SSH, el protocolo de comunicación de red transmite datos a nivel pty.
+-------------+ +------+ +-----+ +----------+
| application |<--------->| sshd |<--------->| ssh |<--------->| terminal |
+-------------+ +------+ +-----+ +----------+
byte stream byte stream byte stream
(char/seq) over TCP/… (char/seq)
Esto es mayormente transparente, excepto que a veces la base de datos del terminal remoto puede no conocer todas las capacidades del terminal local.
Aplicación X11 remota
El protocolo de comunicación entre aplicaciones y el servidor es en sí mismo un flujo de bytes que se puede enviar a través de un protocolo de red como SSH.
+-------------+ +------+ +-----+ +----------+
| application |<---------->| sshd |<------>| ssh |<---------->| X server |
+-------------+ +------+ +-----+ +----------+
X11 protocol X11 over X11 protocol
TCP/…
Esto es en su mayoría transparente, excepto que algunas funciones de aceleración como la decodificación de películas y el renderizado 3D que requieren comunicación directa entre la aplicación y la pantalla no están disponibles.
Si desea ver esto en un sistema Unix que sea lo suficientemente pequeño como para ser comprensible, busque en Xv6. Es más o menos la mítica sexta edición de Unix la que se convirtió en la base del famoso comentario de John Lion, que durante mucho tiempo circuló como samizdat. Su código fue reelaborado para compilar bajo ANSI C y teniendo en cuenta desarrollos modernos, como multiprocesadores.