static void svgalib_key_close ()
{
keyboard_setdefaulteventhandler ();
keyboard_clearstate ();
keyboard_translatekeys (0);
keyboard_close ();
}
int keyboard_init_return_fd(void) {
char *ptr;
keyboard_translatekeys(translatemode); /* Honour 'nosigint' setting */
/* Install default keyboard handler. */
__svgalib_keyboard_eventhandler = default_handler;
__svgalib_open_devconsole();
__svgalib_kbd_fd = __svgalib_tty_fd; /* We are initialized. */
if (ioctl(__svgalib_kbd_fd, KDGKBMODE, &oldkbmode)) {
printf("svgalib: cannot get keyboard mode.\n");
return -1;
}
tcgetattr(__svgalib_kbd_fd, &oldkbdtermios);
newkbdtermios = oldkbdtermios;
newkbdtermios.c_lflag &= ~(ICANON | ECHO | ISIG);
newkbdtermios.c_iflag &= ~(ISTRIP | IGNCR | ICRNL | INLCR | IXOFF | IXON);
newkbdtermios.c_cc[VMIN] = 0; /* Making these 0 seems to have the */
newkbdtermios.c_cc[VTIME] = 0; /* desired effect. */
tcsetattr(__svgalib_kbd_fd, TCSAFLUSH, &newkbdtermios);
ioctl(__svgalib_kbd_fd, KDSKBMODE, K_MEDIUMRAW);
keyboard_clearstate();
__svgalib_read_options(kbd_config_options, kbd_process_option);
/* Check SVGALIB_KEYMAP env var */
if ( (ptr = getenv("SVGALIB_KEYMAP")) != 0) {
kbd_load_keymap(ptr);
}
return __svgalib_kbd_fd; /* OK, return fd. */
}
static void svgalib_key_flush ()
{
keyboard_update ();
keyboard_clearstate ();
memset (key_state, 0, 128);
}
static int keyboard_getevents(int wait)
{
/* Read keyboard device, and handle events. */
/* If wait == 1, process at least one event and return. */
/* If wait == 0, handle all accumulated events; return 0 if no events */
/* were handled, 1 otherwise. */
/* Wait mode doesn't seem to work very well; the keyboard repeat delay is */
/* present. I don't understand fcntl. */
static unsigned char buf[KBDREADBUFFERSIZE];
static int kfdmode = 0; /* 1 = DELAY, 0 = NDELAY */
int bytesread, i;
int eventhandled;
eventhandled = 0;
again:
if (kfdmode == 1) { /* This only happens for wait == 1. */
#if 0
struct termios kbdtermios;
#endif
int flags;
/* We don't want to wait, set NDELAY mode. */
fcntl(__svgalib_kbd_fd, F_GETFL, &flags);
fcntl(__svgalib_kbd_fd, F_SETFL, flags | O_NDELAY);
#if 0
tcgetattr(__svgalib_kbd_fd, &kbdtermios);
kbdtermios.c_lflag = kbdtermios.c_lflag & ~(ICANON | ECHO | ISIG);
kbdtermios.c_cc[VMIN] = 0;
kbdtermios.c_cc[VTIME] = 0;
tcsetattr(__svgalib_kbd_fd, TCSANOW, &kbdtermios);
#endif
kfdmode = 0;
}
bytesread = read(__svgalib_kbd_fd, buf, KBDREADBUFFERSIZE);
if (wait == 1 && bytesread < 1) {
#if 0
struct termios kbdtermios;
#endif
int flags;
/* We already handled an event, no need to wait for another. */
if (eventhandled)
return 1;
/* Wait mode, we'll sleep on reads. */
fcntl(__svgalib_kbd_fd, F_GETFL, &flags);
fcntl(__svgalib_kbd_fd, F_SETFL, flags & ~O_NDELAY);
#if 0
tcgetattr(__svgalib_kbd_fd, &kbdtermios);
kbdtermios.c_lflag = kbdtermios.c_lflag & ~(ICANON | ECHO | ISIG);
kbdtermios.c_cc[VMIN] = 0;
kbdtermios.c_cc[VTIME] = 0;
tcsetattr(__svgalib_kbd_fd, TCSANOW, &kbdtermios);
#endif
kfdmode = 1;
bytesread = read(__svgalib_kbd_fd, buf, 1);
}
if (wait == 0 && bytesread < 1)
return eventhandled;
if (bytesread >= 1)
eventhandled = 1;
for (i = 0; i < bytesread; i++) {
unsigned char scancode = kbd_mapkey(buf[i] & 0x7f);
unsigned char is_pressed = (buf[i] & 0x80) ? 0 : 1;
/* Check for ctrl-c. */
switch (scancode) {
case SCANCODE_C:
c_state = is_pressed;
break;
case SCANCODE_LEFTCONTROL:
case SCANCODE_RIGHTCONTROL:
ctrl_state = is_pressed;
break;
case SCANCODE_LEFTALT:
case SCANCODE_RIGHTALT:
alt_state = is_pressed;
break;
case SCANCODE_LEFTWIN:
case SCANCODE_RIGHTWIN:
win_state = is_pressed;
break;
case SCANCODE_F1 ... SCANCODE_F10:
functionkey_state = (is_pressed) ?
functionkey_state | 1 << (scancode - SCANCODE_F1) :
functionkey_state & ~(1 << (scancode - SCANCODE_F1));
break;
}
if (fake_mouse_events && __svgalib_mouse_fd > -1) {
int n;
for(n = 0; n < fme_used; n++)
if(fake_mouse_events[n][0].scancode == scancode)
break;
if(fme_numberof[n])
{
int i;
int dx=0, dy=0, dz=0, but=0; /* To gather mutiple events into one */
int but_changed = 0;
struct FakeMouseEvent *event;
for (i = 0; i < fme_numberof[n]; i++) {
int request_at_down;
short flags;
event = &fake_mouse_events[n][i];
if (!is_pressed)
event -> flags &= ~FMEF_TRIGGERED;
flags = event -> flags;
request_at_down = (event -> flags & FMEF_AT_PRESS) ? 1 : 0;
#ifdef DEBUG_KEYBOARD
printf(" event type: %ld; flags: %ld; data: %ld; is_pressed: %ld\n", (long)event->type, (long)flags, (long)event->data, (long)is_pressed);
#endif
if (flags & FMEF_AT_BOTH || request_at_down == is_pressed) {
#ifdef DEBUG_KEYBOARD
printf(" flags: %ld\n", (long)flags);
#endif
if ( (! (flags & FMEF_TRIGGERED)) || flags & FMEF_REPEAT) {
#ifdef DEBUG_KEYBOARD
printf(" triggering\n");
#endif
switch (event -> type) {
case FME_TYPE_BUTTON1:
but = (event -> data) ? but | 4 : but & ~4;
but_changed = 1;
break;
case FME_TYPE_BUTTON2:
but = (event -> data) ? but | 1 : but & ~1;
but_changed = 1;
break;
case FME_TYPE_BUTTON3:
but = (event -> data) ? but | 2 : but & ~2;
but_changed = 1;
break;
case FME_TYPE_IGNOREX:
__svgalib_m_ignore_dx = event -> data;
break;
case FME_TYPE_IGNOREY:
__svgalib_m_ignore_dy = event -> data;
break;
case FME_TYPE_IGNOREZ:
__svgalib_m_ignore_dz = event -> data;
break;
case FME_TYPE_DELTAX:
dx += event -> data;
break;
case FME_TYPE_DELTAY:
dy += event -> data;
break;
case FME_TYPE_DELTAZ:
dz += event -> data;
break;
}
if (is_pressed)
event -> flags |= FMEF_TRIGGERED;
}
}
}
if ((dx || dy || dz || but_changed) && __svgalib_mouse_eventhandler) {
__svgalib_mouse_eventhandler(but, dx, dy, dz, 0, 0, 0);
#ifdef DEBUG_KEYBOARD
printf("\tfake_mouse_event triggered; but: %ld; dx: %ld; dy: %ld; dz: %ld\n",
(long)but, (long)dx, (long)dy, (long)dz);
#endif
}
}
}
if (ctrl_state && c_state && !(translatemode & DONT_CATCH_CTRLC))
raise(SIGINT);
if ((alt_state && functionkey_state)||(win_state && functionkey_state)) {
/* VT switch. */
/* *** what about F11 & F12? */
int j, vt = 0;
struct vt_stat vts;
for (j = 0; j < 12; j++)
if (functionkey_state & (1 << j)) {
vt = j + 1;
if(win_state)j+=12;
break;
}
/* Do not switch vt's if need not to */
ioctl(__svgalib_tty_fd, VT_GETSTATE, &vts);
if(vt != vts.v_active) {
/* if switching vt's, need to clear keystates */
keyboard_clearstate();
/*
* This will generate a signal catched by
* svgalib to restore textmode.
*/
ioctl(__svgalib_tty_fd, VT_ACTIVATE, vt);
return 1;
}
}
__svgalib_keyboard_eventhandler(scancode,
(buf[i] & 0x80) ? KEY_EVENTRELEASE : KEY_EVENTPRESS);
}
/* Handle other events that have accumulated. */
goto again;
}
