示例#1
0
文件: scheme.c 项目: nizmic/nwm
static SCM scm_bind_key(SCM mod_mask, SCM key, SCM proc)
{
    xcb_keysym_t keysym;
    if (scm_is_true(scm_number_p(key)))
        keysym = scm_to_uint32(key);
    else if (scm_is_true(scm_string_p(key))) {
        scm_dynwind_begin(0);
        char *c_key = scm_to_locale_string(key);
        scm_dynwind_free(c_key);
        keysym = get_keysym(c_key);
        scm_dynwind_end();
    }
    else
        return SCM_UNSPECIFIED;
    bind_key(scm_to_uint16(mod_mask), keysym, proc);
    return SCM_UNSPECIFIED;
}
示例#2
0
platform::scancode keyboard::get_scancode( xcb_keycode_t code )
{
	xcb_keysym_t key = get_keysym( code, 0 );

	if ( key == XCB_NO_SYMBOL )
		return platform::scancode::KEY_UNKNOWN;

	if ( key >= XK_a && key <= XK_z )
		return static_cast<platform::scancode>( static_cast<uint32_t>(platform::scancode::KEY_A) + ( key - XK_a ) );

	if ( key >= XK_0 && key <= XK_9 )
		return static_cast<platform::scancode>( static_cast<uint32_t>(platform::scancode::KEY_0) + ( key - XK_0 ) );

	auto c = sym2code.find( key );
	if ( c != sym2code.end() )
		return c->second;

	std::cout << "KEYSYM = " << key << std::endl; 
	return platform::scancode::KEY_UNKNOWN;
}
示例#3
0
static kbd_layout_t *parse_keyboard_layout(const name2keysym_t *table,
					   const char *language,
					   kbd_layout_t * k)
{
    FILE *f;
    char * filename;
    char line[1024];
    int len;

    filename = qemu_find_file(QEMU_FILE_TYPE_KEYMAP, language);

    if (!k)
	k = g_malloc0(sizeof(kbd_layout_t));
    if (!(filename && (f = fopen(filename, "r")))) {
	fprintf(stderr,
		"Could not read keymap file: '%s'\n", language);
	return NULL;
    }
    g_free(filename);
    for(;;) {
	if (fgets(line, 1024, f) == NULL)
            break;
        len = strlen(line);
        if (len > 0 && line[len - 1] == '\n')
            line[len - 1] = '\0';
        if (line[0] == '#')
	    continue;
	if (!strncmp(line, "map ", 4))
	    continue;
	if (!strncmp(line, "include ", 8)) {
	    parse_keyboard_layout(table, line + 8, k);
        } else {
	    char *end_of_keysym = line;
	    while (*end_of_keysym != 0 && *end_of_keysym != ' ')
		end_of_keysym++;
	    if (*end_of_keysym) {
		int keysym;
		*end_of_keysym = 0;
		keysym = get_keysym(table, line);
		if (keysym == 0) {
                    //		    fprintf(stderr, "Warning: unknown keysym %s\n", line);
		} else {
		    const char *rest = end_of_keysym + 1;
		    char *rest2;
		    int keycode = strtol(rest, &rest2, 0);

		    if (rest && strstr(rest, "numlock")) {
			add_to_key_range(&k->keypad_range, keycode);
			add_to_key_range(&k->numlock_range, keysym);
			//fprintf(stderr, "keypad keysym %04x keycode %d\n", keysym, keycode);
		    }

		    if (rest && strstr(rest, "shift"))
			keycode |= SCANCODE_SHIFT;
		    if (rest && strstr(rest, "altgr"))
			keycode |= SCANCODE_ALTGR;
		    if (rest && strstr(rest, "ctrl"))
			keycode |= SCANCODE_CTRL;

		    add_keysym(line, keysym, keycode, k);

		    if (rest && strstr(rest, "addupper")) {
			char *c;
			for (c = line; *c; c++)
			    *c = toupper(*c);
			keysym = get_keysym(table, line);
			if (keysym)
			    add_keysym(line, keysym, keycode | SCANCODE_SHIFT, k);
		    }
		}
	    }
	}
    }
    fclose(f);
    return k;
}
示例#4
0
void handle_x_event ( XEvent& event, 
		      GtkWidget* label )
{
    KeySym key;

    char completion_string_c[BUFSIZ];
    int completion_word_index = 0;
    int completion_flag = FALSE;

        switch(event.type) {
          case KeyPress:
            key = get_keysym(&event);

            if((isalpha(key) || isspace(key) || ispunct(key) || key == XK_BackSpace) && key < 256){
                XevieSendEvent(dpy, &event, XEVIE_UNMODIFIED);
                get_prediction(tolower(key), completion_string_c, FALSE, label);
                
                
                if(((key == ',') ||
                    (key == '.') ||
                    (key == '?') ||
                    (key == ';') ||
                    (key == ':')) && 
                   (completion_word_index == 0) && 
                   (completion_flag == TRUE)) {
					
                    event.xkey.keycode = XKeysymToKeycode(dpy, XK_BackSpace);
                    event.type = KeyPress; 
                    XSendEvent(dpy, InputFocus, TRUE, KeyPressMask, &event);
                    event.type = KeyRelease;
                    XSendEvent(dpy, InputFocus, TRUE, KeyReleaseMask, &event);
           
                    event.type = KeyPress; 
                    XSendEvent(dpy, InputFocus, TRUE, KeyPressMask, &event);
                    event.type = KeyRelease;
                    XSendEvent(dpy, InputFocus, TRUE, KeyReleaseMask, &event);
                    
                    event.xkey.keycode = XKeysymToKeycode(dpy, key);
                    event.type = KeyPress; 
                    XSendEvent(dpy, InputFocus, TRUE, KeyPressMask, &event);
                    event.type = KeyRelease;
                    XSendEvent(dpy, InputFocus, TRUE, KeyReleaseMask, &event);
                
                    event.xkey.keycode = XKeysymToKeycode(dpy, XK_space);
                    event.type = KeyPress; 
                    XSendEvent(dpy, InputFocus, TRUE, KeyPressMask, &event);
                    event.type = KeyRelease;
                    XSendEvent(dpy, InputFocus, TRUE, KeyReleaseMask, &event);
                }

                else if(isspace(key)) completion_word_index = 0;
                else completion_word_index++;
                
                completion_flag = FALSE;
            }
            
            // check for function keys
            else if(((key - XK_F1) >= 0) && ((key - XK_F1) <= no_suggestions-1)) {
            	
            	// inform presage that the prediction was successful.
               	// and ask presage to predict next token
	      get_prediction(tolower(key), completion_string_c, TRUE, label);
               
                char s[64];
                printf("%d\n", completion_word_index  );
                //  send the rest of the completion string and a ' ' to the client 
                while(completion_string_c[completion_word_index] != '\0'){               	
                    s[0] = completion_string_c[completion_word_index];
                    s[1] = '\0';
                    
                    event.xkey.keycode = XKeysymToKeycode(dpy, XStringToKeysym(s));               
                    event.type = KeyPress; 
                    XSendEvent(dpy, InputFocus, TRUE, KeyPressMask, &event);
                    event.type = KeyRelease;
                    XSendEvent(dpy, InputFocus, TRUE, KeyReleaseMask, &event);
               		
                    event.xkey.time++;
                          
                    completion_word_index++;
                }
                completion_word_index = 0;
                completion_flag = TRUE;
                
                event.xkey.keycode = XKeysymToKeycode(dpy, XK_space);
                event.type = KeyPress;
                XSendEvent(dpy, InputFocus, TRUE, KeyPressMask, &event);
                event.type = KeyRelease;
                XSendEvent(dpy, InputFocus, TRUE, KeyReleaseMask, &event);
            }
            else {   			
            	// anything else just send it to the client
            	XevieSendEvent(dpy, &event, XEVIE_UNMODIFIED);
                completion_word_index = 0;
                completion_flag = FALSE;
            }
            break;
            
          case KeyRelease:    			
            XevieSendEvent(dpy, &event, XEVIE_UNMODIFIED);
            break;
            
          default: 
            printf(" unknown event %x\n", event.type); 
            break;   
    	}
}
static kbd_layout_t *parse_keyboard_layout(const name2keysym_t *table,
					   const char *language,
					   kbd_layout_t * k)
{
    FILE *f;
    char file_name[1024];
    char line[1024];
    int len;

    snprintf(file_name, sizeof(file_name),
             "%s/keymaps/%s", bios_dir, language);

    if (!k)
	k = qemu_mallocz(sizeof(kbd_layout_t));
    if (!(f = fopen(file_name, "r"))) {
	fprintf(stderr,
		"Could not read keymap file: '%s'\n", file_name);
	return 0;
    }
    for(;;) {
	if (fgets(line, 1024, f) == NULL)
            break;
        len = strlen(line);
        if (len > 0 && line[len - 1] == '\n')
            line[len - 1] = '\0';
        if (line[0] == '#')
	    continue;
	if (!strncmp(line, "map ", 4))
	    continue;
	if (!strncmp(line, "include ", 8)) {
	    parse_keyboard_layout(table, line + 8, k);
        } else {
	    char *end_of_keysym = line;
	    while (*end_of_keysym != 0 && *end_of_keysym != ' ')
		end_of_keysym++;
	    if (*end_of_keysym) {
		int keysym;
		*end_of_keysym = 0;
		keysym = get_keysym(table, line);
		if (keysym == 0) {
                    //		    fprintf(stderr, "Warning: unknown keysym %s\n", line);
		} else {
		    const char *rest = end_of_keysym + 1;
		    char *rest2;
		    int keycode = strtol(rest, &rest2, 0);

		    if (rest && strstr(rest, "numlock")) {
			add_to_key_range(&k->keypad_range, keycode);
			add_to_key_range(&k->numlock_range, keysym);
			//fprintf(stderr, "keypad keysym %04x keycode %d\n", keysym, keycode);
		    }

		    /* if(keycode&0x80)
		       keycode=(keycode<<8)^0x80e0; */
		    if (keysym < MAX_NORMAL_KEYCODE) {
			//fprintf(stderr,"Setting keysym %s (%d) to %d\n",line,keysym,keycode);
			k->keysym2keycode[keysym] = keycode;
		    } else {
			if (k->extra_count >= MAX_EXTRA_COUNT) {
			    fprintf(stderr,
				    "Warning: Could not assign keysym %s (0x%x) because of memory constraints.\n",
				    line, keysym);
			} else {
#if 0
			    fprintf(stderr, "Setting %d: %d,%d\n",
				    k->extra_count, keysym, keycode);
#endif
			    k->keysym2keycode_extra[k->extra_count].
				keysym = keysym;
			    k->keysym2keycode_extra[k->extra_count].
				keycode = keycode;
			    k->extra_count++;
			}
		    }
		}
	    }
	}
    }
    fclose(f);
    return k;
}
示例#6
0
static int parse_keyboard_layout(kbd_layout_t *k,
                                 const name2keysym_t *table,
                                 const char *language, Error **errp)
{
    int ret;
    FILE *f;
    char * filename;
    char line[1024];
    char keyname[64];
    int len;

    filename = qemu_find_file(QEMU_FILE_TYPE_KEYMAP, language);
    trace_keymap_parse(filename);
    f = filename ? fopen(filename, "r") : NULL;
    g_free(filename);
    if (!f) {
        error_setg(errp, "could not read keymap file: '%s'", language);
        return -1;
    }

    for(;;) {
        if (fgets(line, 1024, f) == NULL) {
            break;
        }
        len = strlen(line);
        if (len > 0 && line[len - 1] == '\n') {
            line[len - 1] = '\0';
        }
        if (line[0] == '#') {
            continue;
        }
        if (!strncmp(line, "map ", 4)) {
            continue;
        }
        if (!strncmp(line, "include ", 8)) {
            error_setg(errp, "keymap include files are not supported any more");
            ret = -1;
            goto out;
        } else {
            int offset = 0;
            while (line[offset] != 0 &&
                   line[offset] != ' ' &&
                   offset < sizeof(keyname) - 1) {
                keyname[offset] = line[offset];
                offset++;
            }
            keyname[offset] = 0;
            if (strlen(keyname)) {
                int keysym;
                keysym = get_keysym(table, keyname);
                if (keysym == 0) {
                    /* warn_report("unknown keysym %s", line);*/
                } else {
                    const char *rest = line + offset + 1;
                    int keycode = strtol(rest, NULL, 0);

                    if (strstr(rest, "shift")) {
                        keycode |= SCANCODE_SHIFT;
                    }
                    if (strstr(rest, "altgr")) {
                        keycode |= SCANCODE_ALTGR;
                    }
                    if (strstr(rest, "ctrl")) {
                        keycode |= SCANCODE_CTRL;
                    }

                    add_keysym(line, keysym, keycode, k);

                    if (strstr(rest, "addupper")) {
                        char *c;
                        for (c = keyname; *c; c++) {
                            *c = qemu_toupper(*c);
                        }
                        keysym = get_keysym(table, keyname);
                        if (keysym) {
                            add_keysym(line, keysym,
                                       keycode | SCANCODE_SHIFT, k);
                        }
                    }
                }
            }
        }
    }

    ret = 0;
out:
    fclose(f);
    return ret;
}