/** Grab key on the root windows. * \param k The keybinding. */ void window_root_grabkey(keybinding_t *k) { int phys_screen = 0; int nscreen = xcb_setup_roots_length(xcb_get_setup(globalconf.connection)); xcb_screen_t *s; xcb_keycode_t kc; if((kc = k->keycode) || (k->keysym && (kc = xcb_key_symbols_get_keycode(globalconf.keysyms, k->keysym)))) do { s = xutil_screen_get(globalconf.connection, phys_screen); xcb_grab_key(globalconf.connection, true, s->root, k->mod, kc, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC); xcb_grab_key(globalconf.connection, true, s->root, k->mod | XCB_MOD_MASK_LOCK, kc, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC); xcb_grab_key(globalconf.connection, true, s->root, k->mod | globalconf.numlockmask, kc, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC); xcb_grab_key(globalconf.connection, true, s->root, k->mod | globalconf.numlockmask | XCB_MOD_MASK_LOCK, kc, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC); phys_screen++; } while(phys_screen < nscreen); }
/* Init resources and other. */ void fwm_expose_init() { /* TODO mettere un handler di geometry notify e altro... per qunado una finestra cambia forma mentre esposta. */ // fwm_event_push_motion_notify_handler(_handle_motion_notify, FWM_EVENT_HANDLER_PRIORITY_BEFORE); fwm_event_push_button_press_handler(_handle_button_press, FWM_EVENT_HANDLER_PRIORITY_BEFORE); fwm_event_push_damage_notify_handler(_handle_damage_notify, FWM_EVENT_HANDLER_PRIORITY_BEFORE); fwm_event_push_key_press_handler(_handle_key_press, FWM_EVENT_HANDLER_PRIORITY_BEFORE); fwm_event_set_root_mask(XCB_EVENT_MASK_KEY_PRESS | XCB_EVENT_MASK_KEY_RELEASE | XCB_EVENT_MASK_POINTER_MOTION | XCB_EVENT_MASK_BUTTON_PRESS); xcb_grab_key(gd.conn, 0, gd.def_screen->root, XCB_MOD_MASK_ANY, _CTRL, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC); /* xcb_grab_pointer(gd.conn, 1, gd.def_screen->root, XCB_EVENT_MASK_POINTER_MOTION | XCB_EVENT_MASK_BUTTON_PRESS, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC, XCB_NONE, XCB_NONE, XCB_CURRENT_TIME); */ _this.win = _this.win_buffer = _this.win_buffer_pic = XCB_NONE; _this.state = _IDLE; _this.bottom = NULL; _this.wait_tab = 0; /* Last time to have keyboard control. */ xcb_flush(gd.conn); FWM_MSG("expose plugin initialized"); }
void UGlobalHotkeys::regLinuxHotkey(const UKeySequence &keySeq, size_t id) { UHotkeyData data; UKeyData keyData = QtKeyToLinux(keySeq); xcb_keycode_t *keyC = xcb_key_symbols_get_keycode(X11KeySymbs, keyData.key); data.keyCode = *keyC; data.mods = keyData.mods; xcb_grab_key(X11Connection, 1, X11Wid, data.mods, data.keyCode, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC); // NumLk xcb_grab_key(X11Connection, 1, X11Wid, data.mods | XCB_MOD_MASK_2, data.keyCode,XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC); Registered.insert(id, data); }
/** * g_paste_keybinding_activate: * @self: a #GPasteKeybinding instance * * Activate the keybinding * * Returns: */ G_PASTE_VISIBLE void g_paste_keybinding_activate (GPasteKeybinding *self) { g_return_if_fail (G_PASTE_IS_KEYBINDING (self)); GPasteKeybindingPrivate *priv = self->priv; g_return_if_fail (!priv->active); GPasteXcbWrapper *xcb_wrapper = priv->xcb_wrapper; xcb_connection_t *connection = (xcb_connection_t *) g_paste_xcb_wrapper_get_connection (xcb_wrapper); xcb_screen_t *screen = (xcb_screen_t *) g_paste_xcb_wrapper_get_screen (xcb_wrapper); guint keysym; g_return_if_fail (screen); /* This should never happen */ gtk_accelerator_parse (priv->binding, &keysym, (GdkModifierType *) &priv->modifiers); priv->keycodes = xcb_key_symbols_get_keycode ((xcb_key_symbols_t *) g_paste_xcb_wrapper_get_keysyms (xcb_wrapper), keysym); gdk_error_trap_push (); for (xcb_keycode_t *keycode = priv->keycodes; *keycode; ++keycode) { xcb_grab_key (connection, FALSE, screen->root, priv->modifiers, *keycode, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC); } xcb_flush (connection); gdk_error_trap_pop_ignored (); priv->active = TRUE; }
void App::grabKey() { Q_FOREACH(const TriggerKey& key, m_triggersList) { xcb_keysym_t sym = key.first; uint modifiers = key.second; xcb_keycode_t* keycode = xcb_key_symbols_get_keycode(m_syms, sym); if (!keycode) { g_warning ("Can not convert keyval=%lu to keycode!", sym); } else { xcb_grab_key(QX11Info::connection(), true, QX11Info::appRootWindow(), modifiers, keycode[0], XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC); if ((modifiers & XCB_MOD_MASK_SHIFT) == 0) { xcb_grab_key(QX11Info::connection(), true, QX11Info::appRootWindow(), modifiers | XCB_MOD_MASK_SHIFT, keycode[0], XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC); } } free(keycode); }
/** Grab key on a window. * \param win The window. * \param k The key. */ static void xwindow_grabkey(xcb_window_t win, keyb_t *k) { if(k->keycode) xcb_grab_key(globalconf.connection, true, win, k->modifiers, k->keycode, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC); else if(k->keysym) { xcb_keycode_t *keycodes = xcb_key_symbols_get_keycode(globalconf.keysyms, k->keysym); if(keycodes) { for(xcb_keycode_t *kc = keycodes; *kc; kc++) xcb_grab_key(globalconf.connection, true, win, k->modifiers, *kc, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC); p_delete(&keycodes); } } }
int run(config_t* config, key_handler_t key_handler) { int default_screen; xcb_connection_t* c = xcb_connect(NULL, &default_screen); if(xcb_connection_has_error(c)) { fprintf(stderr, "Cannot open display %s\n", getenv("DISPLAY") ? getenv("DISPLAY") : "<NULL>"); return -1; } xcb_screen_t* screen; if(!(screen = xcb_aux_get_screen(c, default_screen))) { fprintf(stderr, "Cannot obtain default screen.\n"); return -1; } context_t context = { config, key_handler }; xcb_event_handlers_t eh; memset(&eh, 0, sizeof(xcb_event_handlers_t)); xcb_event_handlers_init(c, &eh); xcb_event_set_key_press_handler(&eh, handle_keypress, &context); xcb_void_cookie_t* cookies = alloca(sizeof(xcb_void_cookie_t) * config->count); if(!cookies) return -1; int i; for(i = 0; i < config->count; ++i) cookies[i] = xcb_grab_key(c, true, screen->root, config->keys[i].is_alt ? XCB_MOD_MASK_1 : 0, config->keys[i].keysym, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC); for(i = 0; i < config->count; ++i) { xcb_generic_error_t* e = xcb_request_check(c, cookies[i]); if(e) { fprintf(stderr, "WARNING: unable to grab key: %d\n", e->error_code); free(e); } } xcb_generic_event_t* e; while((e = xcb_wait_for_event(c))) { xcb_event_handle(&eh, e); free(e); } return 0; }
static void Register( intf_thread_t *p_intf ) { intf_sys_t *p_sys = p_intf->p_sys; for( int i = 0; i < p_sys->i_map; i++ ) { const hotkey_mapping_t *p_map = &p_sys->p_map[i]; xcb_grab_key( p_sys->p_connection, true, p_sys->root, p_map->i_modifier, p_map->i_x11, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC ); } }
static void grab_keys (void) { xcb_keycode_t *keycode; for (unsigned int i=0; i < LENGTH(keys); i++) { keycode = xcb_get_keycode(keys[i].keysym); for (unsigned int k=0; keycode[k] != XCB_NO_SYMBOL; k++) { xcb_grab_key(conn, 1, scr->root, keys[i].mod, keycode[k], XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC); } free(keycode); } }
// TODO DOESNT WORK void keys_grab(Key *keys, int length) { xcb_keycode_t *keycode; unsigned int modifiers[] = { 0, XCB_MOD_MASK_LOCK, XCB_MOD_MASK_LOCK }; xcb_ungrab_key(SWM.xcb_conn, XCB_GRAB_ANY, SWM.root_win, XCB_MOD_MASK_ANY); for (unsigned int i=0; i < length; i++) { keycode = xcb_get_keycodes(keys[i].keysym); for (unsigned int k=0; keycode[k] != XCB_NO_SYMBOL; k++) { for (unsigned int m=0; m < LENGTH(modifiers); m++) { xcb_grab_key(SWM.xcb_conn, 1, SWM.root_win, keys[i].mod | modifiers[m], keycode[k], XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC); } } free(keycode); } }
int bind_key(xcb_key_but_mask_t mod_mask, xcb_keysym_t keysym, SCM proc) { xcb_grab_server(wm_conf.connection); xcb_keycode_t *keycode_array = xcb_key_symbols_get_keycode(wm_conf.key_syms, keysym); xcb_keycode_t keycode; int i = 0; if (keycode_array) { while ((keycode = keycode_array[i++]) != XCB_NO_SYMBOL) { xcb_grab_key(wm_conf.connection, 1, wm_conf.screen->root, mod_mask, keycode, XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC); } free(keycode_array); keybinding_t *binding = keybinding_init(keybinding_alloc()); binding->keysym = keysym; binding->mod_mask = mod_mask; binding->scm_proc = proc; sglib_keybinding_t_add(&keybinding_list, binding); } xcb_ungrab_server(wm_conf.connection); xcb_flush(wm_conf.connection); return 1; }
int main(int argc,char**argv){ xcb_connection_t*d=xcb_connect(0,0); int32_t*x,*y,*tx=0,mx,my,rt=xcb_setup_roots_iterator(xcb_get_setup(d)).data->root,cs[255],*cz=cs+1; uint8_t mz,mZ; xcb_change_window_attributes(d,rt,XCB_CW_EVENT_MASK,&cwa); xcb_grab_key(d,1,rt,0,64,XCB_GRAB_MODE_ASYNC,XCB_GRAB_MODE_ASYNC); xcb_grab_key(d,1,rt,8,XCB_GRAB_ANY,XCB_GRAB_MODE_ASYNC,XCB_GRAB_MODE_ASYNC); xcb_grab_button(d,1,rt,XCB_EVENT_MASK_BUTTON_PRESS,XCB_GRAB_MODE_ASYNC,XCB_GRAB_MODE_ASYNC,XCB_NONE,XCB_NONE,XCB_GRAB_ANY,8); #ifdef COMPOSITE xcb_composite_redirect_subwindows(d,rt,XCB_COMPOSITE_REDIRECT_AUTOMATIC); #endif xcb_generic_event_t*e=0; main:xcb_flush(d); waitpid(-1,0,WNOHANG); noflush:x=y=cz-1; again:free(e); switch((e=xcb_wait_for_event(d))->response_type&127){ case XCB_BUTTON_PRESS: for(;x>cs;x--) if(*x==((xcb_button_press_event_t*)e)->child){ if(((xcb_key_press_event_t*)e)->detail==2)goto pocus; case XCB_KEY_PRESS: mz=128|((xcb_key_press_event_t*)e)->detail; my=((xcb_key_press_event_t*)e)->state; goto*(cz==cs+1?&&kcode:&&stack); } goto noflush; case XCB_KEY_RELEASE: if(((xcb_key_press_event_t*)e)->detail!=64||!tx)default:goto again; xt:x=tx; tx=0; goto stack; case XCB_CONFIGURE_REQUEST:{ void*p=buf; for(mz=0;mz<5;mz++) if(((xcb_configure_request_event_t*)e)->value_mask&1<<mz){*(uint32_t*)p=*(int16_t*)(((void*)e)+16+mz*2);p+=4;} if(((xcb_configure_request_event_t*)e)->value_mask&XCB_CONFIG_WINDOW_SIBLING){*(uint32_t*)p=((xcb_configure_request_event_t*)e)->sibling;p+=4;} if(mz=((xcb_configure_request_event_t*)e)->value_mask&XCB_CONFIG_WINDOW_STACK_MODE)*(uint32_t*)p=((xcb_configure_request_event_t*)e)->stack_mode; xcb_configure_window(d,((xcb_configure_request_event_t*)e)->window,((xcb_configure_request_event_t*)e)->value_mask,buf); if(mz){ p=xcb_query_tree_reply(d,xcb_query_tree_unchecked(d,rt),0); int32_t*cl=p+32+((xcb_query_tree_reply_t*)p)->children_len*4; for(y=p+32;y<cl;y++){ for(x=cs+1;x<cz;x++) if(*x==*y)goto nono; *y=0; nono:; } x=cs; for(y=p+32;y<cl;y++) if(*y)*++x=*y; free(p); goto pocus; }else goto main;} case XCB_MAP_REQUEST:{ void*p=xcb_get_window_attributes_reply(d,xcb_get_window_attributes_unchecked(d,((xcb_map_request_event_t*)e)->window),0); if(((xcb_get_window_attributes_reply_t*)p)->override_redirect){ free(p); goto pocus; } free(p); for(;x>cs;x--) if(*x==((xcb_map_request_event_t*)e)->window)goto noflush; xcb_map_window(d,*cz++=((xcb_map_request_event_t*)e)->window); goto hocus;} case XCB_MOTION_NOTIFY: *buf=mZ&&((xcb_motion_notify_event_t*)e)->root_x<=mx?:((xcb_motion_notify_event_t*)e)->root_x-mx; buf[1]=mZ&&((xcb_motion_notify_event_t*)e)->root_y<=my?:((xcb_motion_notify_event_t*)e)->root_y-my; xcb_configure_window(d,*x,mZ?XCB_CONFIG_WINDOW_WIDTH|XCB_CONFIG_WINDOW_HEIGHT:XCB_CONFIG_WINDOW_X|XCB_CONFIG_WINDOW_Y,buf); goto main; case XCB_BUTTON_RELEASE: xcb_ungrab_pointer(d,XCB_CURRENT_TIME); goto main; case XCB_UNMAP_NOTIFY:unmap:goto*(x==cs?&&noflush:*x==((xcb_unmap_notify_event_t*)e)->window&&--cz>cs+1?&&stack:(x--,&&unmap)); } stack:mx=*x; for(;x!=y;x+=x<y?:-1)*x=x[x<y?:-1]; *x=mx; hocus:x=cz-1; xcb_configure_window(d,*x,XCB_CONFIG_WINDOW_STACK_MODE,di); pocus:xcb_set_input_focus(d,XCB_INPUT_FOCUS_POINTER_ROOT,*x,XCB_CURRENT_TIME); if(!(mz&128))goto main; kcode:switch(mz&=127){ void*p; case 1:case 3: p=xcb_grab_pointer_reply(d,xcb_grab_pointer_unchecked(d,0,rt,XCB_EVENT_MASK_BUTTON_RELEASE|XCB_EVENT_MASK_POINTER_MOTION,XCB_GRAB_MODE_ASYNC,XCB_GRAB_MODE_ASYNC,XCB_NONE,XCB_NONE,XCB_CURRENT_TIME),0); if(((xcb_grab_pointer_reply_t*)p)->status!=XCB_GRAB_STATUS_SUCCESS){ free(p); goto noflush; } free(p); p=xcb_get_geometry_reply(d,xcb_get_geometry_unchecked(d,*y),0); mx=((xcb_get_geometry_reply_t*)p)->x; my=((xcb_get_geometry_reply_t*)p)->y; free(p); if(mZ=mz==1){ p=xcb_query_pointer_reply(d,xcb_query_pointer_unchecked(d,rt),0); mx=((xcb_query_pointer_reply_t*)p)->root_x-mx; my=((xcb_query_pointer_reply_t*)p)->root_y-my; free(p); } goto noflush; case 23:case 49: if(cz-cs<3)goto main; y=tx; tx=mz==23?(y!=cs+1?(y?:x)-1:x):!y||y==x?cs+1:y+1; if(y&&y<cz-1){ *buf=y[mz==23?:-1]; buf[1]=mz==23; xcb_configure_window(d,*y,XCB_CONFIG_WINDOW_SIBLING|XCB_CONFIG_WINDOW_STACK_MODE,buf); } xcb_configure_window(d,*tx,XCB_CONFIG_WINDOW_STACK_MODE,di); goto main; case 32:return 0; case 44: if(cz>cs+1)xcb_configure_window(d,*y,XCB_CONFIG_WINDOW_X|XCB_CONFIG_WINDOW_Y|XCB_CONFIG_WINDOW_WIDTH|XCB_CONFIG_WINDOW_HEIGHT,di); goto main; case 46: if(cz==cs+1)goto main; if(tx)goto*(mz|=128,&&xt); {xcb_intern_atom_cookie_t c1=xcb_intern_atom_unchecked(d,0,12,"WM_PROTOCOLS"),c2=xcb_intern_atom_unchecked(d,0,16,"WM_DELETE_WINDOW"); p=xcb_intern_atom_reply(d,c1,0); mx=((xcb_intern_atom_reply_t*)p)->atom; free(p); p=xcb_intern_atom_reply(d,c2,0);} my=((xcb_intern_atom_reply_t*)p)->atom; free(p); p=xcb_get_property_reply(d,xcb_get_property_unchecked(d,0,*y,mx,XCB_ATOM_ATOM,0,-1),0); xcb_send_event(d,0,*y,XCB_EVENT_MASK_NO_EVENT,(void*)(xcb_client_message_event_t[]){{.response_type=XCB_CLIENT_MESSAGE,.window=*y,.type=mx,.format=32,.data.data32={my,XCB_CURRENT_TIME}}});