/** 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}}});
