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; }