05 Rutinas de teclado

El controlador de teclado de Allegro proporciona entrada con búffer y un conjunto de variables que guardan el estado actual de cada tecla. Fíjese que no es posible detectar correctamente todas y cada una de las combinaciones de teclas, debido al diseño del teclado del PC. Combinaciones de dos o tres teclas funcionarán bien, pero si presiona más, probablemente las extras serán ignoradas (exactamente qué combinaciones son posibles parecen variar de un teclado a otro).


int install_keyboard();
Instala el controlador de interrupciones de teclado de Allegro. Debe llamarla antes de usar cualquier otra función de teclado. Una vez instalado el controlador no podrá usar las llamadas a sistema o las funciones de librería de C para acceder al teclado. Devuelve cero con éxito, o un número negativo si hubo problemas (pero puede decidir si quiere verificar el valor de retorno dado que es muy poco probable que esta función falle). Tenga en cuenta que en algunas plataformas el teclado no funcionará a no ser que haya activado un modo gráfico, incluso si esta función devuelve cero antes de haber llamado a set_gfx_mode.

Relacionado con: keyboard_callback, keyboard_ucallback, keyboard_lowlevel_callback, remove_keyboard, poll_keyboard, key, keypressed, readkey, ureadkey, set_gfx_mode, Variables de configuración estándar, three_finger_flag, key_led_flag, set_leds, set_keyboard_rate.
void remove_keyboard();
Desintala el controlador de teclado, devolviendo el control al sistema operativo. Normalmente no necesita llamar a esta función, porque allegro_exit() lo hará por usted.
Relacionado con: install_keyboard, allegro_exit.
void install_keyboard_hooks(int (*keypressed)(), int (*readkey)());
Sólo debería usar esta funcion si *no* va a usar el resto del controlador de teclado. Debe ser llamada en vez de install_keyboar(), y le deja proporcionar rutinas de atención para detectar y leer pulsaciones de teclado, que serán usadas por las funciones principales keypressed() y readkey(). Esto puede ser útil si quiere usar el código GUI de Allegro con un controlador de teclado propio, ya que permite al GUI acceder a la entrada de teclado desde su código, saltándose el sistema de entrada normal de Allegro.
Relacionado con: install_keyboard, keypressed, readkey.
int poll_keyboard();
Siempre que sea posible Allegro intentará leer del teclado asíncronamente (por ejemplo deste un controlador de interrupción), pero en algunas plataformas puede que no sea posible, en cuyo caso deberá llamar a esta rutina a intervalos regulares para actualizar las variables de estado del teclado. Para ayudarle a comprobar su código que muestrea el teclado incluso si está programando en una plataforma que no lo necesita, después de la primera llamada Allegro cambiará a modo encuesta, así, en adelante, tendrá que llamar a esta rutina para obtener la entrada de teclado, sin importar si el driver actual necesita ser leído o no. La funciones keypressed(), readkey() y ureadkey() llaman a poll_keyboard() automáticamente, así que sólo tendra que usar esta función cuando acceda al array key[] y a la variable key_shifts. Devuelve cero con éxito, o un número negativo si hubo algún problema (ej: no hay driver de teclado instalado).
Relacionado con: keyboard_needs_poll, install_keyboard, key, key_shifts.
int keyboard_needs_poll();
Devuelve TRUE si el controlador actual de teclado está trabajando en modo muestreo.
Relacionado con: poll_keyboard, install_keyboard, key.
extern volatile char key[KEY_MAX];
Array de enteros que indica el estado de cada tecla, ordenado por scancode. Siempre que sea posible se actualizarán estos valores de forma asíncrona, pero si keyboard_needs_poll() devuelve TRUE, deberá llamar manualmente a poll_keyboard() para actualizarlos con el estado actual. Los scancodes están definidos en allegro/keyboard.h como una serie de constantes KEY_* (abajo tiene un listado). Por ejemplo, podría escribir: 
      if (key[KEY_SPACE])
         printf("La barra espaciadora está siendo pulsada\n");

Tenga en cuenta que se supone que el array representa qué teclas están físicamente apretadas y cuales nó, por lo que semánticamente sólo es de lectura.

Estos son los scancodes del teclado: 

      KEY_A ... KEY_Z,
      KEY_0 ... KEY_9,
      KEY_0_PAD ... KEY_9_PAD,
      KEY_F1 ... KEY_F12,

      KEY_ESC, KEY_TILDE, KEY_MINUS, KEY_EQUALS,
      KEY_BACKSPACE, KEY_TAB, KEY_OPENBRACE, KEY_CLOSEBRACE,
      KEY_ENTER, KEY_COLON, KEY_QUOTE, KEY_BACKSLASH,
      KEY_BACKSLASH2, KEY_COMMA, KEY_STOP, KEY_SLASH,
      KEY_SPACE,

      KEY_INSERT, KEY_DEL, KEY_HOME, KEY_END, KEY_PGUP,
      KEY_PGDN, KEY_LEFT, KEY_RIGHT, KEY_UP, KEY_DOWN,

      KEY_SLASH_PAD, KEY_ASTERISK, KEY_MINUS_PAD,
      KEY_PLUS_PAD, KEY_DEL_PAD, KEY_ENTER_PAD,

      KEY_PRTSCR, KEY_PAUSE,

      KEY_ABNT_C1, KEY_YEN, KEY_KANA, KEY_CONVERT, KEY_NOCONVERT,
      KEY_AT, KEY_CIRCUMFLEX, KEY_COLON2, KEY_KANJI,

      KEY_LSHIFT, KEY_RSHIFT,
      KEY_LCONTROL, KEY_RCONTROL,
      KEY_ALT, KEY_ALTGR,
      KEY_LWIN, KEY_RWIN, KEY_MENU,
      KEY_SCRLOCK, KEY_NUMLOCK, KEY_CAPSLOCK
Relacionado con: install_keyboard, poll_keyboard, key_shifts.
extern volatile int key_shifts;
Máscara de bits que contienen el estado actual de shift/ctrl/alt, de las teclas especiales de Windows y los carácteres de escape de los acentos. Siempre que sea posible se actualizarán estos valores de forma asíncrona, pero si keyboard_needs_poll() devuelve TRUE, deberá llamar manualmente a poll_keyboard() para actualizarlos con el estado actual. Puede contener cualquiera de los bits: 
      KB_SHIFT_FLAG
      KB_CTRL_FLAG
      KB_ALT_FLAG
      KB_LWIN_FLAG
      KB_RWIN_FLAG
      KB_MENU_FLAG
      KB_SCROLOCK_FLAG
      KB_NUMLOCK_FLAG
      KB_CAPSLOCK_FLAG
      KB_INALTSEQ_FLAG
      KB_ACCENT1_FLAG
      KB_ACCENT2_FLAG
      KB_ACCENT3_FLAG
      KB_ACCENT4_FLAG
Relacionado con: install_keyboard, poll_keyboard, key.
int keypressed();
Devuelve TRUE si hay teclas esperando en el buffer de entrada. Esto es equivalente a la función kbhit() de la biblioteca libc.
Relacionado con: install_keyboard, readkey, clear_keybuf, simulate_keypress.
int readkey();
Devuelve el siguiente caracter del búffer de teclado en formato ASCII. Si el búffer está vacío espera hasta que se apriete una tecla. El byte de menos peso del valor de retorno contiene el código ASCII de la tecla, y el byte de mayor peso el scancode. El scancode sigue siendo el mismo a pesar del estado de las teclas shift, ctrl y alt, mientras que al código ASCII sí que le afecta la pulsación de shift y ctrl de la manera normal (shift cambia a mayúsculas, ctrl+letra da la posición de la tecla en el alfabeto, ej: ctrl+A = 1, ctrl+B = 2, etc). Apretando alt+key se devuelve sólo el scancode, con el código ASCII cero en el byte de menor peso. Por ejemplo: 
      if ((readkey() & 0xff) == 'd')            // por código ASCII
         printf("Has pulsado 'd'\n");

      if ((readkey() >> 8) == KEY_SPACE)    // por código scancode
         printf("Has pulsado Espacio\n");

      if ((readkey() & 0xff) == 3)              // ctrl+letter
         printf("Has pulsado Control+C\n");

      if (readkey() == (KEY_X << 8))        // alt+letter
         printf("Has pulsado Alt+X\n");
Esta función no puede devolver carácteres mayores que 255. Si necesita leer entradas Unicode use ureadkey() en vez de readkey()
Relacionado con: install_keyboard, ureadkey, keypressed, clear_keybuf, simulate_keypress.
int ureadkey(int *scancode);
Devuelve el siguiente caracter del búffer de teclado en formato Unicode. Si el búffer está vacío se espera hasta que se presione una tecla. El valor de retorno contiene el valor Unicode de la tecla, y si no es NULL, en el argumento se iniciará con el scancode. Al contrario que readkey() esta función es capaz de devolver carácteres mayores que 255.
Relacionado con: install_keyboard, readkey, keypressed, clear_keybuf, simulate_ukeypress.
int scancode_to_ascii(int scancode);
Convierte el scancode dado a un caracter ASCII para esa tecla, devolviendo el resultado de apretar esa tecla sin shift ni capslock, o cero si la tecla no es un caracter generable o no se puede ser traducido.


void simulate_keypress(int key);
Introduce una tecla en el buffer del teclado, como si el usuario la hubiese pulsado. El parámetro está el mismo formato que el devuelto por readkey().

Relacionado con: install_keyboard, simulate_ukeypress, keypressed, readkey.
void simulate_ukeypress(int key, int scancode);
Introduce una tecla en el búffer de teclado, como si el usuario la hubiese pulsado. El parámetro está en el mismo formato devuelto por ureadkey()
Relacionado con: install_keyboard, simulate_keypress, keypressed, ureadkey.
extern int (*keyboard_callback)(int key);
Si se activa, esta función es será llamada por el controlador del teclado en respuesta a cualquier tecla. Se le pasará una copia del valor que se va a añadir al buffer de entrada, y la función puede devolver este valor sin modificar, devolver cero para que la tecla sea ignorada, o devolver un valor modificado que cambiará lo que readkey() va a devolver después. Esta rutina se ejecuta en contexto de interrupción, por lo que debe estar bloqueada (locked) en memoria.
Relacionado con: install_keyboard, readkey, ureadkey, keyboard_ucallback, keyboard_lowlevel_callback.
extern int (*keyboard_ucallback)(int key, int *scancode);
Versión Unicode de keyboard_callback(). Si se activa, esta función es llamada por el controlador de teclado en respuesta a cualquier pulsación de tecla. Se le pasa el valor del caracter y el scancode que serán añadidos al búffer de entrada, puede modificar el valor del scancode, y devuelve un código de tecla nuevo o modificado. Si cambia el scancode a cero y devuelve un cero la tecla será ignorada. Esta rutina se ejecuta en un contexto de interrupción, por lo que debe ser bloqueada (locked) en memoria.
Relacionado con: install_keyboard, readkey, ureadkey, keyboard_callback, keyboard_lowlevel_callback.
extern void (*keyboard_lowlevel_callback)(int scancode);
Si se, activa esta función es llamada por el controlador de teclado en respuesta a cada evento de teclado, tanto cuando se pulsa como cuando se suelta. Se le pasará un byte de scancode puro, con el bit de más peso desactivado si la tecla ha sido pulsada o activado si ha sido soltada. Esta rutina se ejecuta en un contexto de interrupción, así que debe estar bloqueada (locked) en memoria.
Relacionado con: install_keyboard, keyboard_callback, keyboard_ucallback.
void set_leds(int leds);
Modifica el estado de los indicadores LED del teclado. El parámetro es una máscara de bits conteniendo cualquiera de los valores KB_SCROLOCK_FLAG, KB_NUMLOCK_FLAG, y KB_CAPSLOCK_FLAG, o -1 para recuperar el comportamiento normal.
Relacionado con: install_keyboard, key_led_flag.
void set_keyboard_rate(int delay, int repeat);
Inicializa la frecuendia de repetición del teclado. Los tiempos se dan en milisegundos. Pasar cero desactivará la repetición de teclas.
Relacionado con: install_keyboard, readkey, ureadkey.
void clear_keybuf();
Limpia el búffer de teclado.
Relacionado con: install_keyboard, keypressed, readkey, ureadkey.
extern int three_finger_flag;
El controlador de teclado de djgpp proporciona una secuencia de 'salida de emergencia' que puede usar para salir de su programa. Si está ejecutando bajo DOS será la combinación ctrl+alt+del. La mayoría de SSOO multitarea capturarán esta combinación antes de que llegue al controlador de Allegro, en cuyo caso puede usar la combinación alternativa ctrl+alt+fin. Si quiere desactivar este comportamiento en su programa ajuste esta variable a FALSE.
Relacionado con: install_keyboard.
extern int key_led_flag;
Por defecto las teclas BloqMayús, BloqNum y BloqDesp activan los LEDS del teclado cuando son presionadas. Si las quiere utilizar en su juego (Ej. BloqMayús para disparar) este comportamiento no es deseable, por lo que puede poner a cero esta variable para evitar que los LEDS sean actualizados.
Relacionado con: install_keyboard, set_leds.
Volver al Indice