keyevent.c

添加系统调用。。。在LINUX下添加一个新的系统调用。在文件中添加自己的系统调用的源代码

        }

        /* First see if our KeySym is already in the mapping */
        key_event->shift = FALSE;
#ifndef ALWAYS_OVERWRITE
        for (i = 0; i <= key_max - key_min; i++) {
                if (keysyms[i * key_codes + 1] == keysym)
                        key_event->shift = TRUE;
                if (keysyms[i * key_codes] == keysym || key_event->shift) {
                        key_event->keycode = key_min + i;
                        key_recycles++;

                        /* Bump the allocation count if this is an
                           allocateable KeyCode */
                        if (usable[key_event->keycode] >= KEY_USABLE)
                                usable[key_event->keycode]++;

                        return;
                }
        }
#endif

        /* Key overwrites may be disabled, in which case we're out of luck */
        if (key_disable_overwrite) {
                key_event->keycode = -1;
                key_event->keysym = 0;
                g_warning("Not allowed to overwrite KeyCode for %s",
                          XKeysymToString(keysym));
                return;
        }

        /* If not, find a usable KeyCode in the mapping */
        for (start = key_offset++; ; key_offset++) {
                if (key_offset > key_max - key_min)
                        key_offset = 0;
                if (usable[key_min + key_offset] == KEY_USABLE &&
                    !pressed[key_min + key_offset])
                        break;

                /* If we can't find one, invalidate the event */
                if (key_offset == start) {
                        key_event->keycode = -1;
                        key_event->keysym = 0;
                        g_warning("Failed to allocate KeyCode for %s",
                                  XKeysymToString(keysym));
                        return;
                }
        }
        key_overwrites++;
        key_event->keycode = key_min + key_offset;
        usable[key_event->keycode] = KEY_ALLOCATED;

        /* Modify the slot to hold our character */
        keysyms[key_offset * key_codes] = keysym;
        keysyms[key_offset * key_codes + 1] = keysym;
        XChangeKeyboardMapping(GDK_DISPLAY(), key_event->keycode, key_codes,
                               keysyms + key_offset * key_codes, 1);
        XSync(GDK_DISPLAY(), False);

        g_debug("Overwrote KeyCode %d for %s", key_event->keycode,
                XKeysymToString(keysym));
}

void key_event_new(KeyEvent *key_event, unsigned int keysym)
/* Filters locks and shifts but allocates other keys normally */
{
        key_event->keysym = keysym;
        if (is_modifier(keysym))
                return;
        key_event_allocate(key_event, keysym);
}

void key_event_free(KeyEvent *key_event)
/* Release resources associated with and invalidate a key event */
{
        if (key_event->keycode >= key_min && key_event->keycode <= key_max &&
            usable[key_event->keycode] == KEY_ALLOCATED)
                usable[key_event->keycode] = KEY_USABLE;
        key_event->keycode = -1;
        key_event->keysym = 0;
}

void key_event_press(KeyEvent *key_event)
/* Press the KeyCode specified in the event */
{
        /* Track modifiers without actually using them */
        if (key_event->keysym == XK_Shift_L ||
            key_event->keysym == XK_Shift_R) {
                key_shifted++;
                return;
        } else if (key_event->keysym == XK_Caps_Lock) {
                key_caps_locked = !key_caps_locked;
                return;
        } else if (key_event->keysym == XK_Num_Lock) {
                key_num_locked = !key_num_locked;
                return;
        }

        /* Invalid event */
        if (key_event->keycode < key_min || key_event->keycode > key_max)
                return;

        /* If this KeyCode is already pressed, something is wrong */
        if (pressed[key_event->keycode]) {
                g_debug("KeyCode %d is already pressed", key_event->keycode);
                return;
        }

        /* Keep track of what KeyCodes we pressed down */
        pressed[key_event->keycode] = TRUE;

        /* Press our keycode */
        if (key_event->shift)
                press_keycode(ke_shift.keycode);
        press_keycode(key_event->keycode);
        XSync(GDK_DISPLAY(), False);
}

void key_event_release(KeyEvent *key_event)
{
        /* Track modifiers without actually using them */
        if (key_event->keysym == XK_Shift_L ||
            key_event->keysym == XK_Shift_R) {
                key_shifted--;
                return;
        }

        /* Invalid key event */
        if (key_event->keycode < key_min || key_event->keycode > key_max)
                return;

        /* Keep track of what KeyCodes are pressed because of us */
        pressed[key_event->keycode] = FALSE;

        /* Release our keycode */
        release_keycode(key_event->keycode);
        if (key_event->shift)
                release_keycode(ke_shift.keycode);
        XSync(GDK_DISPLAY(), False);
}

#ifdef X_HAVE_UTF8_STRING
void key_event_send_char(int unichar)
{
        KeyEvent key_event;
        KeySym keysym;

        /* Get the keysym for the unichar (may be unsupported) */
        keysym = XStringToKeysym(va("U%04X", unichar));
        if (!keysym) {
                g_warning("XStringToKeysym failed to get Keysym for '%C'",
                          unichar);
                return;
        }

        key_event_new(&key_event, keysym);
        key_event_press(&key_event);
        key_event_release(&key_event);
        key_event_free(&key_event);
}
#else
#warning X_HAVE_UTF8_STRING is undefined, Unicode support is disabled!
void key_event_send_char(int unichar)
{
        KeyCode keycode;

        /* Get the keycode for an existing key */
        keycode = XKeysymToKeycode(GDK_DISPLAY(), keysym);
        if (!keycode) {
                g_warning("XKeysymToKeycode failed to find KeyCode for '%C'",
                          unichar);
                return;
        }

        type_keycode(keycode);
}
#endif

void key_event_send_enter()
{
        type_keycode(ke_enter.keycode);
}

void key_event_update_mappings(void)
{
        int i, j;

        /* Get the keyboard mapping */
        XDisplayKeycodes(GDK_DISPLAY(), &key_min, &key_max);
        if (keysyms)
                XFree(keysyms);
        keysyms = XGetKeyboardMapping(GDK_DISPLAY(), key_min,
                                      key_max - key_min + 1, &key_codes);

        /* Get the modifier mapping and variable masks */
        if (modmap)
                XFreeModifiermap(modmap);
        modmap = XGetModifierMapping(GDK_DISPLAY());
        for (i = 0; i < 8; i++)
                for (j = 0; j < modmap->max_keypermod; j++) {
                        KeyCode keycode;
                        KeySym keysym;

                        keycode = modmap->modifiermap
                                  [i * modmap->max_keypermod + j];
                        if (keycode < key_min || keycode > key_max)
                                continue;
                        keysym = keysyms[(keycode - key_min) * key_codes];
                        if (keysym == XK_Alt_L || keysym == XK_Alt_R) {
                                alt_mask = 1 << i;
                                break;
                        } else if (keysym == XK_Meta_L || keysym == XK_Meta_R) {
                                meta_mask = 1 << i;
                                break;
                        } else if (keysym == XK_Num_Lock) {
                                num_lock_mask = 1 << i;
                                break;
                        }
                }

        /* Release any keys pressed by the user */
        reset_keyboard();
}

int key_event_init(void)
{
	int a, b, c, d;

#ifndef X_HAVE_UTF8_STRING
        g_warning("Compiled without Unicode support!");
#endif

	/* Make sure Xtest is supported */
	if(!XTestQueryExtension(GDK_DISPLAY(), &a, &b, &c, &d))
		g_critical("Xtest not supported!");
	else
		g_debug("Xtest version %d.%d.%d.%d", a, b, c, d);

        /* Clear the array that keeps track of our pressed keys */
        memset(pressed, 0, sizeof (pressed));

        /* Update keycode and modifiers mappings */
        key_event_update_mappings();

        /* Scan for available KeyCodes */
        setup_usable();

        /* Get some common key events */
        key_event_allocate(&ke_shift, XK_Shift_L);
        key_event_allocate(&ke_caps_lock, XK_Caps_Lock);
        key_event_allocate(&ke_num_lock, XK_Num_Lock);
        key_event_allocate(&ke_enter, XK_Return);

        return 0;
}

void key_event_cleanup(void)
{
        cleanup_usable();
}