[BOX32] Improved X11 event handling

18 files changed, 2188 insertions, 580 deletions

diff --git a/src/libtools/my_x11_conv.c b/src/libtools/my_x11_conv.c
index 6f8bd50d..b4f4b091 100644
--- a/src/libtools/my_x11_conv.c
+++ b/src/libtools/my_x11_conv.c
@@ -12,478 +12,6 @@
 #include "my_x11_defs_32.h"
 #include "my_x11_conv.h"
 
-void convertXEvent(my_XEvent_32_t* dst, my_XEvent_t* src)
-{
-    if(!src->type) {
-        // This is an XErrorEvent, and it's different!
-        dst->xerror.type = src->xerror.type;
-        dst->xerror.display = to_ptrv(FindDisplay(src->xerror.display));
-        dst->xerror.resourceid = to_ulong(src->xerror.resourceid);
-        dst->xerror.serial = to_ulong(src->xerror.serial);
-        dst->xerror.error_code = src->xerror.error_code;
-        dst->xerror.request_code = src->xerror.request_code;
-        dst->xerror.minor_code = src->xerror.minor_code;
-        return;
-    }
-    // convert the XAnyEvent first, as it's a common set
-    dst->type = src->type;
-    dst->xany.display = to_ptrv(FindDisplay(src->xany.display));
-    dst->xany.window = to_ulong(src->xany.window);
-    dst->xany.send_event = src->xany.serial;
-    dst->xany.serial = to_ulong(src->xany.serial);
-    switch(src->type) {
-        case XEVT_KeyPress:
-        case XEVT_KeyRelease:
-            dst->xkey.root = to_ulong(src->xkey.root);
-            dst->xkey.subwindow = to_ulong(src->xkey.subwindow);
-            dst->xkey.time = to_ulong(src->xkey.time);
-            dst->xkey.x = src->xkey.x;
-            dst->xkey.y = src->xkey.y;
-            dst->xkey.x_root = src->xkey.x_root;
-            dst->xkey.y_root = src->xkey.y_root;
-            dst->xkey.state = src->xkey.state;
-            dst->xkey.keycode = src->xkey.keycode;
-            dst->xkey.same_screen = src->xkey.same_screen;
-            break;
-        case XEVT_ButtonPress:
-        case XEVT_ButtonRelease:
-            dst->xbutton.root = to_ulong(src->xbutton.root);
-            dst->xbutton.subwindow = to_ulong(src->xbutton.subwindow);
-            dst->xbutton.time = to_ulong(src->xbutton.time);
-            dst->xbutton.x = src->xbutton.x;
-            dst->xbutton.y = src->xbutton.y;
-            dst->xbutton.x_root = src->xbutton.x_root;
-            dst->xbutton.y_root = src->xbutton.y_root;
-            dst->xbutton.state = src->xbutton.state;
-            dst->xbutton.button = src->xbutton.button;
-            dst->xbutton.same_screen = src->xbutton.same_screen;
-            break;
-        case XEVT_MotionNotify:
-            dst->xmotion.root = to_ulong(src->xmotion.root);
-            dst->xmotion.subwindow = to_ulong(src->xmotion.subwindow);
-            dst->xmotion.time = to_ulong(src->xmotion.time);
-            dst->xmotion.x = src->xmotion.x;
-            dst->xmotion.y = src->xmotion.y;
-            dst->xmotion.x_root = src->xmotion.x_root;
-            dst->xmotion.y_root = src->xmotion.y_root;
-            dst->xmotion.state = src->xmotion.state;
-            dst->xmotion.is_hint = src->xmotion.is_hint;
-            dst->xmotion.same_screen = src->xmotion.same_screen;
-            break;
-        case XEVT_EnterNotify:
-        case XEVT_LeaveNotify:
-            dst->xcrossing.root = to_ulong(src->xcrossing.root);
-            dst->xcrossing.subwindow = to_ulong(src->xcrossing.subwindow);
-            dst->xcrossing.time = to_ulong(src->xcrossing.time);
-            dst->xcrossing.x = src->xcrossing.x;
-            dst->xcrossing.y = src->xcrossing.y;
-            dst->xcrossing.x_root = src->xcrossing.x_root;
-            dst->xcrossing.y_root = src->xcrossing.y_root;
-            dst->xcrossing.mode = src->xcrossing.mode;
-            dst->xcrossing.detail = src->xcrossing.detail;
-            dst->xcrossing.same_screen = src->xcrossing.same_screen;
-            dst->xcrossing.focus = src->xcrossing.focus;
-            dst->xcrossing.state = src->xcrossing.state;
-            break;
-        case XEVT_FocusIn:
-        case XEVT_FocusOut:
-            dst->xfocus.mode = src->xfocus.mode;
-            dst->xfocus.detail = src->xfocus.detail;
-            break;
-        case XEVT_KeymapNotify:
-            memcpy(dst->xkeymap.key_vector, src->xkeymap.key_vector, 32);
-            break;
-        case XEVT_Expose:
-            dst->xexpose.x = src->xexpose.x;
-            dst->xexpose.y = src->xexpose.y;
-            dst->xexpose.width = src->xexpose.width;
-            dst->xexpose.height = src->xexpose.height;
-            dst->xexpose.count = src->xexpose.count;
-            break;
-        case XEVT_GraphicsExpose:
-            dst->xgraphicsexpose.x = src->xgraphicsexpose.x;
-            dst->xgraphicsexpose.y = src->xgraphicsexpose.y;
-            dst->xgraphicsexpose.width = src->xgraphicsexpose.width;
-            dst->xgraphicsexpose.height = src->xgraphicsexpose.height;
-            dst->xgraphicsexpose.count = src->xgraphicsexpose.count;
-            dst->xgraphicsexpose.major_code = src->xgraphicsexpose.major_code;
-            dst->xgraphicsexpose.minor_code = src->xgraphicsexpose.minor_code;
-            break;
-        case XEVT_NoExpose:
-            dst->xnoexpose.major_code = src->xnoexpose.major_code;
-            dst->xnoexpose.minor_code = src->xnoexpose.minor_code;
-            break;
-        case XEVT_VisibilityNotify:
-            dst->xvisibility.state = src->xvisibility.state;
-            break;
-        case XEVT_CreateNotify:
-            dst->xcreatewindow.window = to_ulong(src->xcreatewindow.window);
-            dst->xcreatewindow.x = src->xcreatewindow.x;
-            dst->xcreatewindow.y = src->xcreatewindow.y;
-            dst->xcreatewindow.width = src->xcreatewindow.width;
-            dst->xcreatewindow.height = src->xcreatewindow.height;
-            dst->xcreatewindow.border_width = src->xcreatewindow.border_width;
-            dst->xcreatewindow.override_redirect = src->xcreatewindow.override_redirect;
-            break;
-        case XEVT_DestroyNotify:
-            dst->xdestroywindow.window = to_ulong(src->xdestroywindow.window);
-            break;
-        case XEVT_UnmapNotify:
-            dst->xunmap.window = to_ulong(src->xunmap.window);
-            dst->xunmap.from_configure = src->xunmap.from_configure;
-            break;
-        case XEVT_MapNotify:
-            dst->xmap.window = to_ulong(src->xmap.window);
-            dst->xmap.override_redirect = src->xmap.override_redirect;
-            break;
-        case XEVT_MapRequest:
-            dst->xmaprequest.window = to_ulong(src->xmaprequest.window);
-            break;
-        case XEVT_ReparentNotify:
-            dst->xreparent.window = to_ulong(src->xreparent.window);
-            dst->xreparent.parent = to_ulong(src->xreparent.parent);
-            dst->xreparent.x = src->xreparent.x;
-            dst->xreparent.y = src->xreparent.y;
-            dst->xreparent.override_redirect = src->xreparent.override_redirect;
-            break;
-        case XEVT_ConfigureNotify:
-            dst->xconfigure.window = to_ulong(src->xconfigure.window);
-            dst->xconfigure.x = src->xconfigure.x;
-            dst->xconfigure.y = src->xconfigure.y;
-            dst->xconfigure.width = src->xconfigure.width;
-            dst->xconfigure.height = src->xconfigure.height;
-            dst->xconfigure.border_width = src->xconfigure.border_width;
-            dst->xconfigure.above = to_ulong(src->xconfigure.above);
-            dst->xconfigure.override_redirect = src->xconfigure.override_redirect;
-            break;
-        case XEVT_ConfigureRequest:
-            dst->xconfigurerequest.window = to_ulong(src->xconfigurerequest.window);
-            dst->xconfigurerequest.x = src->xconfigurerequest.x;
-            dst->xconfigurerequest.y = src->xconfigurerequest.y;
-            dst->xconfigurerequest.width = src->xconfigurerequest.width;
-            dst->xconfigurerequest.height = src->xconfigurerequest.height;
-            dst->xconfigurerequest.border_width = src->xconfigurerequest.border_width;
-            dst->xconfigurerequest.above = to_ulong(src->xconfigurerequest.above);
-            dst->xconfigurerequest.detail = src->xconfigurerequest.detail;
-            dst->xconfigurerequest.value_mask = to_ulong(src->xconfigurerequest.value_mask);
-            break;
-        case XEVT_GravityNotify:
-            dst->xgravity.window = to_ulong(src->xgravity.window);
-            dst->xgravity.x = src->xgravity.x;
-            dst->xgravity.y = src->xgravity.y;
-            break;
-        case XEVT_ResizeRequest:
-            dst->xresizerequest.width = src->xresizerequest.width;
-            dst->xresizerequest.height = src->xresizerequest.height;
-            break;
-        case XEVT_CirculateNotify:
-            dst->xcirculate.window = to_ulong(src->xcirculate.window);
-            dst->xcirculate.place = src->xcirculate.place;
-            break;
-        case XEVT_CirculateRequest:
-            dst->xcirculaterequest.window = to_ulong(src->xcirculaterequest.window);
-            dst->xcirculaterequest.place = src->xcirculaterequest.place;
-            break;
-        case XEVT_PropertyNotify:
-            dst->xproperty.atom = to_ulong(src->xproperty.atom);
-            dst->xproperty.time = to_ulong(src->xproperty.time);
-            dst->xproperty.state = src->xproperty.state;
-            break;
-        case XEVT_SelectionClear:
-            dst->xselectionclear.selection = to_ulong(src->xselectionclear.selection);
-            dst->xselectionclear.time = to_ulong(src->xselectionclear.time);
-            break;
-        case XEVT_SelectionRequest:
-            dst->xselectionrequest.requestor = to_ulong(src->xselectionrequest.requestor);
-            dst->xselectionrequest.selection = to_ulong(src->xselectionrequest.selection);
-            dst->xselectionrequest.target = to_ulong(src->xselectionrequest.target);
-            dst->xselectionrequest.property = to_ulong(src->xselectionrequest.property);
-            dst->xselectionrequest.time = to_ulong(src->xselectionrequest.time);
-            break;
-        case XEVT_SelectionNotify:
-            dst->xselection.selection = to_ulong(src->xselection.selection);
-            dst->xselection.target = to_ulong(src->xselection.target);
-            dst->xselection.property = to_ulong(src->xselection.property);
-            dst->xselection.time = to_ulong(src->xselection.time);
-            break;
-        case XEVT_ColormapNotify:
-            dst->xcolormap.colormap = to_ulong(src->xcolormap.colormap);
-            dst->xcolormap.c_new = src->xcolormap.c_new;
-            dst->xcolormap.state = src->xcolormap.state;
-            break;
-        case XEVT_ClientMessage:
-            dst->xclient.message_type = to_ulong(src->xclient.message_type);
-            dst->xclient.format = src->xclient.format;
-            if(src->xclient.format==32)
-                for(int i=0; i<5; ++i) {
-                    if(((src->xclient.data.l[i]&0xffffffff80000000LL))==0xffffffff80000000LL)
-                        dst->xclient.data.l[i] = to_ulong(src->xclient.data.l[i]&0xffffffff);   // negative value...
-                    else
-                        dst->xclient.data.l[i] = to_ulong(src->xclient.data.l[i]);
-                }
-            else
-                memcpy(dst->xclient.data.b, src->xclient.data.b, 20);
-            break;
-        case XEVT_MappingNotify:
-            dst->xmapping.request = src->xmapping.request;
-            dst->xmapping.first_keycode = src->xmapping.first_keycode;
-            dst->xmapping.count = src->xmapping.count;
-            break;
-        case XEVT_GenericEvent:
-            dst->xgeneric.extension = src->xgeneric.extension;
-            dst->xgeneric.evtype = src->xgeneric.evtype;
-            break;
-        default:
-            printf_log(LOG_INFO, "Warning, unsupported 32bits XEvent type=%d\n", src->type);
-    }
-}
-void unconvertXEvent(my_XEvent_t* dst, my_XEvent_32_t* src)
-{
-    if(!src->type) {
-        // This is an XErrorEvent, and it's different!
-        dst->xerror.type = src->xerror.type;
-        dst->xerror.display = getDisplay(from_ptrv(src->xerror.display));
-        dst->xerror.resourceid = from_ulong(src->xerror.resourceid);
-        dst->xerror.serial = from_ulong(src->xerror.serial);
-        dst->xerror.error_code = src->xerror.error_code;
-        dst->xerror.request_code = src->xerror.request_code;
-        dst->xerror.minor_code = src->xerror.minor_code;
-        return;
-    }
-    // convert the XAnyEvent first, as it's a common set
-    dst->type = src->type;
-    dst->xany.display = getDisplay(from_ptrv(src->xany.display));
-    dst->xany.window = from_ulong(src->xany.window);
-    dst->xany.send_event = src->xany.serial;
-    dst->xany.serial = from_ulong(src->xany.serial);
-    switch(src->type) {
-        case XEVT_KeyPress:
-        case XEVT_KeyRelease:
-            dst->xkey.root = from_ulong(src->xkey.root);
-            dst->xkey.subwindow = from_ulong(src->xkey.subwindow);
-            dst->xkey.time = from_ulong(src->xkey.time);
-            dst->xkey.x = src->xkey.x;
-            dst->xkey.y = src->xkey.y;
-            dst->xkey.x_root = src->xkey.x_root;
-            dst->xkey.y_root = src->xkey.y_root;
-            dst->xkey.state = src->xkey.state;
-            dst->xkey.keycode = src->xkey.keycode;
-            dst->xkey.same_screen = src->xkey.same_screen;
-            break;
-        case XEVT_ButtonPress:
-        case XEVT_ButtonRelease:
-            dst->xbutton.root = from_ulong(src->xbutton.root);
-            dst->xbutton.subwindow = from_ulong(src->xbutton.subwindow);
-            dst->xbutton.time = from_ulong(src->xbutton.time);
-            dst->xbutton.x = src->xbutton.x;
-            dst->xbutton.y = src->xbutton.y;
-            dst->xbutton.x_root = src->xbutton.x_root;
-            dst->xbutton.y_root = src->xbutton.y_root;
-            dst->xbutton.state = src->xbutton.state;
-            dst->xbutton.button = src->xbutton.button;
-            dst->xbutton.same_screen = src->xbutton.same_screen;
-            break;
-        case XEVT_MotionNotify:
-            dst->xmotion.root = from_ulong(src->xmotion.root);
-            dst->xmotion.subwindow = from_ulong(src->xmotion.subwindow);
-            dst->xmotion.time = from_ulong(src->xmotion.time);
-            dst->xmotion.x = src->xmotion.x;
-            dst->xmotion.y = src->xmotion.y;
-            dst->xmotion.x_root = src->xmotion.x_root;
-            dst->xmotion.y_root = src->xmotion.y_root;
-            dst->xmotion.state = src->xmotion.state;
-            dst->xmotion.is_hint = src->xmotion.is_hint;
-            dst->xmotion.same_screen = src->xmotion.same_screen;
-            break;
-        case XEVT_EnterNotify:
-        case XEVT_LeaveNotify:
-            dst->xcrossing.root = from_ulong(src->xcrossing.root);
-            dst->xcrossing.subwindow = from_ulong(src->xcrossing.subwindow);
-            dst->xcrossing.time = from_ulong(src->xcrossing.time);
-            dst->xcrossing.x = src->xcrossing.x;
-            dst->xcrossing.y = src->xcrossing.y;
-            dst->xcrossing.x_root = src->xcrossing.x_root;
-            dst->xcrossing.y_root = src->xcrossing.y_root;
-            dst->xcrossing.mode = src->xcrossing.mode;
-            dst->xcrossing.detail = src->xcrossing.detail;
-            dst->xcrossing.same_screen = src->xcrossing.same_screen;
-            dst->xcrossing.focus = src->xcrossing.focus;
-            dst->xcrossing.state = src->xcrossing.state;
-            break;
-        case XEVT_FocusIn:
-        case XEVT_FocusOut:
-            dst->xfocus.mode = src->xfocus.mode;
-            dst->xfocus.detail = src->xfocus.detail;
-            break;
-        case XEVT_KeymapNotify:
-            memcpy(dst->xkeymap.key_vector, src->xkeymap.key_vector, 32);
-            break;
-        case XEVT_Expose:
-            dst->xexpose.x = src->xexpose.x;
-            dst->xexpose.y = src->xexpose.y;
-            dst->xexpose.width = src->xexpose.width;
-            dst->xexpose.height = src->xexpose.height;
-            dst->xexpose.count = src->xexpose.count;
-            break;
-        case XEVT_GraphicsExpose:
-            dst->xgraphicsexpose.x = src->xgraphicsexpose.x;
-            dst->xgraphicsexpose.y = src->xgraphicsexpose.y;
-            dst->xgraphicsexpose.width = src->xgraphicsexpose.width;
-            dst->xgraphicsexpose.height = src->xgraphicsexpose.height;
-            dst->xgraphicsexpose.count = src->xgraphicsexpose.count;
-            dst->xgraphicsexpose.major_code = src->xgraphicsexpose.major_code;
-            dst->xgraphicsexpose.minor_code = src->xgraphicsexpose.minor_code;
-            break;
-        case XEVT_NoExpose:
-            dst->xnoexpose.major_code = src->xnoexpose.major_code;
-            dst->xnoexpose.minor_code = src->xnoexpose.minor_code;
-            break;
-        case XEVT_VisibilityNotify:
-            dst->xvisibility.state = src->xvisibility.state;
-            break;
-        case XEVT_CreateNotify:
-            dst->xcreatewindow.window = from_ulong(src->xcreatewindow.window);
-            dst->xcreatewindow.x = src->xcreatewindow.x;
-            dst->xcreatewindow.y = src->xcreatewindow.y;
-            dst->xcreatewindow.width = src->xcreatewindow.width;
-            dst->xcreatewindow.height = src->xcreatewindow.height;
-            dst->xcreatewindow.border_width = src->xcreatewindow.border_width;
-            dst->xcreatewindow.override_redirect = src->xcreatewindow.override_redirect;
-            break;
-        case XEVT_DestroyNotify:
-            dst->xdestroywindow.window = from_ulong(src->xdestroywindow.window);
-            break;
-        case XEVT_UnmapNotify:
-            dst->xunmap.window = from_ulong(src->xunmap.window);
-            dst->xunmap.from_configure = src->xunmap.from_configure;
-            break;
-        case XEVT_MapNotify:
-            dst->xmap.window = from_ulong(src->xmap.window);
-            dst->xmap.override_redirect = src->xmap.override_redirect;
-            break;
-        case XEVT_MapRequest:
-            dst->xmaprequest.window = from_ulong(src->xmaprequest.window);
-            break;
-        case XEVT_ReparentNotify:
-            dst->xreparent.window = from_ulong(src->xreparent.window);
-            dst->xreparent.parent = from_ulong(src->xreparent.parent);
-            dst->xreparent.x = src->xreparent.x;
-            dst->xreparent.y = src->xreparent.y;
-            dst->xreparent.override_redirect = src->xreparent.override_redirect;
-            break;
-        case XEVT_ConfigureNotify:
-            dst->xconfigure.window = from_ulong(src->xconfigure.window);
-            dst->xconfigure.x = src->xconfigure.x;
-            dst->xconfigure.y = src->xconfigure.y;
-            dst->xconfigure.width = src->xconfigure.width;
-            dst->xconfigure.height = src->xconfigure.height;
-            dst->xconfigure.border_width = src->xconfigure.border_width;
-            dst->xconfigure.above = from_ulong(src->xconfigure.above);
-            dst->xconfigure.override_redirect = src->xconfigure.override_redirect;
-            break;
-        case XEVT_ConfigureRequest:
-            dst->xconfigurerequest.window = from_ulong(src->xconfigurerequest.window);
-            dst->xconfigurerequest.x = src->xconfigurerequest.x;
-            dst->xconfigurerequest.y = src->xconfigurerequest.y;
-            dst->xconfigurerequest.width = src->xconfigurerequest.width;
-            dst->xconfigurerequest.height = src->xconfigurerequest.height;
-            dst->xconfigurerequest.border_width = src->xconfigurerequest.border_width;
-            dst->xconfigurerequest.above = from_ulong(src->xconfigurerequest.above);
-            dst->xconfigurerequest.detail = src->xconfigurerequest.detail;
-            dst->xconfigurerequest.value_mask = from_ulong(src->xconfigurerequest.value_mask);
-            break;
-        case XEVT_GravityNotify:
-            dst->xgravity.window = from_ulong(src->xgravity.window);
-            dst->xgravity.x = src->xgravity.x;
-            dst->xgravity.y = src->xgravity.y;
-            break;
-        case XEVT_ResizeRequest:
-            dst->xresizerequest.width = src->xresizerequest.width;
-            dst->xresizerequest.height = src->xresizerequest.height;
-            break;
-        case XEVT_CirculateNotify:
-            dst->xcirculate.window = from_ulong(src->xcirculate.window);
-            dst->xcirculate.place = src->xcirculate.place;
-            break;
-        case XEVT_CirculateRequest:
-            dst->xcirculaterequest.window = from_ulong(src->xcirculaterequest.window);
-            dst->xcirculaterequest.place = src->xcirculaterequest.place;
-            break;
-        case XEVT_PropertyNotify:
-            dst->xproperty.atom = from_ulong(src->xproperty.atom);
-            dst->xproperty.time = from_ulong(src->xproperty.time);
-            dst->xproperty.state = src->xproperty.state;
-            break;
-        case XEVT_SelectionClear:
-            dst->xselectionclear.selection = from_ulong(src->xselectionclear.selection);
-            dst->xselectionclear.time = from_ulong(src->xselectionclear.time);
-            break;
-        case XEVT_SelectionRequest:
-            dst->xselectionrequest.requestor = from_ulong(src->xselectionrequest.requestor);
-            dst->xselectionrequest.selection = from_ulong(src->xselectionrequest.selection);
-            dst->xselectionrequest.target = from_ulong(src->xselectionrequest.target);
-            dst->xselectionrequest.property = from_ulong(src->xselectionrequest.property);
-            dst->xselectionrequest.time = from_ulong(src->xselectionrequest.time);
-            break;
-        case XEVT_SelectionNotify:
-            dst->xselection.selection = from_ulong(src->xselection.selection);
-            dst->xselection.target = from_ulong(src->xselection.target);
-            dst->xselection.property = from_ulong(src->xselection.property);
-            dst->xselection.time = from_ulong(src->xselection.time);
-            break;
-        case XEVT_ColormapNotify:
-            dst->xcolormap.colormap = from_ulong(src->xcolormap.colormap);
-            dst->xcolormap.c_new = src->xcolormap.c_new;
-            dst->xcolormap.state = src->xcolormap.state;
-            break;
-        case XEVT_ClientMessage:
-            dst->xclient.message_type = from_ulong(src->xclient.message_type);
-            dst->xclient.format = src->xclient.format;
-            if(src->xclient.format==32)
-                for(int i=0; i<5; ++i) dst->xclient.data.l[i] = from_ulong(src->xclient.data.l[i]);
-            else
-                memcpy(dst->xclient.data.b, src->xclient.data.b, 20);
-            break;
-        case XEVT_MappingNotify:
-            dst->xmapping.request = src->xmapping.request;
-            dst->xmapping.first_keycode = src->xmapping.first_keycode;
-            dst->xmapping.count = src->xmapping.count;
-            break;
-        case XEVT_GenericEvent:
-            dst->xgeneric.extension = src->xgeneric.extension;
-            dst->xgeneric.evtype = src->xgeneric.evtype;
-            break;
-
-        default:
-            printf_log(LOG_INFO, "Warning, unsupported 32bits (un)XEvent type=%d\n", src->type);
-    }
-}
-
-void convert_XErrorEvent_to_32(void* d, void* s)
-{
-    my_XErrorEvent_t* src = s;
-    my_XErrorEvent_32_t* dst = d;
-    dst->type = src->type;
-    dst->display = to_ptrv(FindDisplay(src->display));
-    dst->resourceid = to_ulong(src->resourceid);
-    dst->serial = to_ulong(src->serial);
-    dst->error_code = src->error_code;
-    dst->request_code = src->request_code;
-    dst->minor_code = src->minor_code;
-}
-void convert_XErrorEvent_to_64(void* d, void* s)
-{
-    my_XErrorEvent_32_t* src = s;
-    my_XErrorEvent_t* dst = d;
-    dst->minor_code = src->minor_code;
-    dst->request_code = src->request_code;
-    dst->error_code = src->error_code;
-    dst->serial = from_ulong(src->serial);
-    dst->resourceid = from_ulong(src->resourceid);
-    dst->display = getDisplay(from_ptrv(src->display));
-    dst->type = src->type;
-}
-
 #define N_DISPLAY 4
 my_XDisplay_t* my32_Displays_64[N_DISPLAY] = {0};
 struct my_XFreeFuncs_32 my32_free_funcs_32[N_DISPLAY] = {0};
@@ -531,6 +59,7 @@ void convert_Screen_to_32(void* d, void* s)
     dst->white_pixel = to_ulong(src->white_pixel);
     dst->black_pixel = to_ulong(src->black_pixel);
     dst->max_maps = src->max_maps;
+    dst->min_maps = src->min_maps;
     dst->backing_store = src->backing_store;
     dst->save_unders = src->save_unders;
     dst->root_input_mask = to_long(src->root_input_mask);
@@ -589,7 +118,15 @@ void* addDisplay(void* d)
     ret->conn_checker = dpy->conn_checker;
     ret->proto_major_version = dpy->proto_major_version;
     ret->proto_minor_version = dpy->proto_minor_version;
+    ret->resource_base = to_ulong(dpy->resource_base);
+    ret->resource_mask = to_ulong(dpy->resource_mask);
+    ret->resource_id = to_ulong(dpy->resource_id);
     ret->xdefaults = to_cstring(dpy->xdefaults);
+    ret->resource_shift = dpy->resource_shift;
+    ret->byte_order = dpy->byte_order;
+    ret->bitmap_unit = dpy->bitmap_unit;
+    ret->bitmap_pad = dpy->bitmap_pad;
+    ret->bitmap_bit_order = dpy->bitmap_bit_order;
     ret->display_name = to_cstring(dpy->display_name);
     ret->default_screen = dpy->default_screen;
     ret->nscreens = dpy->nscreens;
@@ -1264,4 +801,70 @@ void* inplace_XRRPropertyInfo_shrink(void* a)
     dst->values = to_ptrv(src->values);
 
     return a;
-}
\ No newline at end of file
+}
+
+void inplace_XIDeviceInfo_shrink(void* a, int n)
+{
+    if(!a || !n) return;
+    my_XIDeviceInfo_32_t* dst = a;
+    my_XIDeviceInfo_t* src = a;
+
+    for(int i=0; i<n; ++i, ++src, ++dst) {
+        dst->deviceid = src->deviceid;
+        dst->name = to_ptrv(src->name);
+        dst->use = src->use;
+        dst->attachment = src->attachment;
+        dst->enabled = src->enabled;
+        for(int j=0; j<src->num_classes; ++j)
+            ((ptr_t*)src->classes)[j] = to_ptrv(src->classes[j]);
+        dst->num_classes = src->num_classes;
+        dst->classes = to_ptrv(src->classes);
+    }
+    // mark last record, even on only 1 record, thos last 2 uint32_t are free
+    dst->deviceid = 0;
+    dst->name = 0;
+}
+
+int inplace_XIDeviceInfo_enlarge(void* a)
+{
+    if(!a) return 0;
+    my_XIDeviceInfo_t* dst = a;
+    my_XIDeviceInfo_32_t* src = a;
+    int n = 0;
+    while(src[n].deviceid && src[n].name) ++n;
+    src+=n-1;
+    dst+=n-1;
+    for(int i=n-1; i>=0; --i, --src, --dst) {
+        dst->classes = from_ptrv(src->classes);
+        dst->num_classes = src->num_classes;
+        dst->enabled = src->enabled;
+        dst->attachment = src->attachment;
+        dst->use = src->use;
+        dst->name = from_ptrv(src->name);
+        dst->deviceid = src->deviceid;
+        for(int j=dst->num_classes-1; j>=0; --j)
+            dst->classes[j] = from_ptrv(((ptr_t*)dst->classes)[j]);
+    }
+    return n;
+}
+
+void inplace_XDevice_shrink(void* a)
+{
+    if(!a) return;
+    my_XDevice_t* src = a;
+    my_XDevice_32_t* dst = a;
+
+    dst->device_id = src->device_id;
+    dst->num_classes = src->num_classes;
+    dst->classes = to_ptrv(src->classes);
+}
+void inplace_XDevice_enlarge(void* a)
+{
+    if(!a) return;
+    my_XDevice_32_t* src = a;
+    my_XDevice_t* dst = a;
+
+    dst->classes = from_ptrv(src->classes);
+    dst->num_classes = src->num_classes;
+    dst->device_id = src->device_id;
+}
diff --git a/src/libtools/my_x11_conv.h b/src/libtools/my_x11_conv.h
index 254c58bb..9a39fe4e 100644
--- a/src/libtools/my_x11_conv.h
+++ b/src/libtools/my_x11_conv.h
@@ -78,4 +78,17 @@ void inplace_XRRProviderResources_shrink(void* a);
 void inplace_XRRProviderResources_enlarge(void* a);
 void* inplace_XRRPropertyInfo_shrink(void* a);
 
+void inplace_XIDeviceInfo_shrink(void* a, int n);
+int inplace_XIDeviceInfo_enlarge(void* a);
+
+void inplace_XDevice_shrink(void* a);
+void inplace_XDevice_enlarge(void* a);
+
+void register_XDevice_events(my_XDevice_t* a);
+void unregister_XDevice_events(my_XDevice_t* a);
+void register_XFixes_events(int event_base);
+void unregister_XFixes_events();
+void register_XRandR_events(int event_base);
+void unregister_XRandR_events();
+
 #endif//MY_X11_CONV
\ No newline at end of file
diff --git a/src/libtools/my_x11_defs.h b/src/libtools/my_x11_defs.h
index 2c104307..ad1e2de3 100644
--- a/src/libtools/my_x11_defs.h
+++ b/src/libtools/my_x11_defs.h
@@ -954,6 +954,276 @@ typedef struct my_XDevice_s {
      my_XInputClassInfo_t*  classes;
 } my_XDevice_t;
 
+typedef struct my_XDeviceKeyEvent_s
+{
+    int            type;
+    unsigned long  serial;
+    int            send_event;
+    void*          display; //Display*
+    XID            window;
+    XID            deviceid;
+    XID            root;
+    XID            subwindow;
+    unsigned long  time;
+    int            x, y;
+    int            x_root;
+    int            y_root;
+    unsigned int   state;
+    unsigned int   keycode;
+    int            same_screen;
+    unsigned int   device_state;
+    unsigned char  axes_count;
+    unsigned char  first_axis;
+    int            axis_data[6];
+} my_XDeviceKeyEvent_t;
+typedef my_XDeviceKeyEvent_t my_XDeviceButtonEvent_t;
+typedef struct my_XDeviceMotionEvent_s
+{
+    int            type;
+    unsigned long  serial;
+    int            send_event;
+    void*          display; //Display*
+    XID            window;
+    XID            deviceid;
+    XID            root;
+    XID            subwindow;
+    unsigned long  time;
+    int            x, y;
+    int            x_root;
+    int            y_root;
+    unsigned int   state;
+    char           is_hint;
+    int            same_screen;
+    unsigned int   device_state;
+    unsigned char  axes_count;
+    unsigned char  first_axis;
+    int            axis_data[6];
+} my_XDeviceMotionEvent_t;
+typedef struct my_XDeviceFocusChangeEvent_s
+{
+    int           type;
+    unsigned long serial;
+    int           send_event;
+    void*         display;  //Display*
+    XID           window;
+    XID           deviceid;
+    int           mode;
+    int           detail;
+    unsigned long time;
+} my_XDeviceFocusChangeEvent_t;
+typedef struct my_XProximityNotifyEvent_s
+{
+    int            type;
+    unsigned long  serial;
+    int            send_event;
+    void*          display; //Display*
+    XID            window;
+    XID            deviceid;
+    XID            root;
+    XID            subwindow;
+    unsigned long  time;
+    int            x, y;
+    int            x_root;
+    int            y_root;
+    unsigned int   state;
+    int            same_screen;
+    unsigned int   device_state;
+    unsigned char  axes_count;
+    unsigned char  first_axis;
+    int            axis_data[6];
+} my_XProximityNotifyEvent_t;
+typedef struct my_XDeviceStateNotifyEvent_s
+{
+    int           type;
+    unsigned long serial;
+    int           send_event;
+    void*         display;  //Display*
+    XID           window;
+    XID           deviceid;
+    unsigned long time;
+    int           num_classes;
+    char	      data[64];
+} my_XDeviceStateNotifyEvent_t;
+typedef struct my_XDeviceMappingEvent_s
+{
+    int           type;
+    unsigned long serial;
+    int           send_event;
+    void*         display;
+    XID           window;
+    XID           deviceid;
+    unsigned long time;
+    int           request;
+    int           first_keycode;
+    int           count;
+} my_XDeviceMappingEvent_t;
+typedef struct my_XChangeDeviceNotifyEvent_s
+{
+    int           type;
+    unsigned long serial;
+    int           send_event;
+    void*         display;
+    XID           window;
+    XID           deviceid;
+    unsigned long time;
+    int           request;
+} my_XChangeDeviceNotifyEvent_t;
+typedef struct my_XDevicePresenceNotifyEvent_s
+{
+    int           type;
+    unsigned long serial;
+    int           send_event;
+    void*         display;
+    XID           window;
+    unsigned long time;
+    int           devchange;
+    XID           deviceid;
+    XID           control;
+} my_XDevicePresenceNotifyEvent_t;
+typedef struct my_XDevicePropertyNotifyEvent_s
+{
+    int           type;
+    unsigned long serial;
+    int           send_event;
+    void*         display;
+    XID           window;
+    unsigned long time;
+    XID           deviceid;
+    XID           atom;
+    int           state;
+} my_XDevicePropertyNotifyEvent_t;
+
+typedef struct my_XFixesSelectionNotifyEvent_s
+{
+    int type;
+    unsigned long serial;
+    int send_event;
+    void* display;
+    XID window;
+    int subtype;
+    XID owner;
+    XID selection;
+    unsigned long timestamp;
+    unsigned long selection_timestamp;
+} my_XFixesSelectionNotifyEvent_t;
+typedef struct my_XFixesCursorNotifyEvent_s
+{
+    int type;
+    unsigned long serial;
+    int send_event;
+    void* display;
+    XID window;
+    int subtype;
+    unsigned long cursor_serial;
+    unsigned long timestamp;
+    XID cursor_name;
+} my_XFixesCursorNotifyEvent_t;
+
+typedef struct my_XRRScreenChangeNotifyEvent_s
+{
+    int type;
+    unsigned long serial;
+    int send_event;
+    void* display;
+    XID window;
+    XID root;
+    unsigned long timestamp;
+    unsigned long config_timestamp;
+    uint16_t size_index;
+    uint16_t subpixel_order;
+    uint16_t rotation;
+    int width;
+    int height;
+    int mwidth;
+    int mheight;
+} my_XRRScreenChangeNotifyEvent_t;
+typedef struct my_XRRNotifyEvent_s
+{
+    int type;
+    unsigned long serial;
+    int send_event;
+    void* display;
+    XID window;
+    int subtype;
+} my_XRRNotifyEvent_t;
+typedef struct my_XRROutputChangeNotifyEvent_s
+{
+    int type;
+    unsigned long serial;
+    int send_event;
+    void* display;
+    XID window;
+    int subtype;
+    XID output;
+    XID crtc;
+    XID mode;
+    uint16_t rotation;
+    uint16_t connection;
+    uint16_t subpixel_order;
+} my_XRROutputChangeNotifyEvent_t;
+typedef struct my_XRRCrtcChangeNotifyEvent_s
+{
+    int type;
+    unsigned long serial;
+    int send_event;
+    void* display;
+    XID window;
+    int subtype;
+    XID crtc;
+    XID mode;
+    uint16_t rotation;
+    int x, y;
+    unsigned int width, height;
+} my_XRRCrtcChangeNotifyEvent_t;
+typedef struct my_XRROutputPropertyNotifyEvent_s
+{
+    int type;
+    unsigned long serial;
+    int send_event;
+    void* display;
+    XID window;
+    int subtype;
+    XID output;
+    XID property;
+    unsigned long timestamp;
+    int state;
+} my_XRROutputPropertyNotifyEvent_t;
+typedef struct my_XRRProviderChangeNotifyEvent_s
+{
+    int type;
+    unsigned long serial;
+    int send_event;
+    void* display;
+    XID window;
+    int subtype;
+    XID provider;
+    unsigned long timestamp;
+    unsigned int current_role;
+} my_XRRProviderChangeNotifyEvent_t;
+typedef struct my_XRRProviderPropertyNotifyEvent_s
+{
+    int type;
+    unsigned long serial;
+    int send_event;
+    void* display;
+    XID window;
+    int subtype;
+    XID provider;
+    XID property;
+    unsigned long timestamp;
+    int state;
+} my_XRRProviderPropertyNotifyEvent_t;
+typedef struct my_XRRResourceChangeNotifyEvent_s
+{
+    int type;
+    unsigned long serial;
+    int send_event;
+    void* display;
+    XID window;
+    int subtype;
+    unsigned long timestamp;
+} my_XRRResourceChangeNotifyEvent_t;
+
 typedef struct my_XcursorCursors_s {
     void*      dpy;     //Display*
     int        ref;
diff --git a/src/libtools/my_x11_defs_32.h b/src/libtools/my_x11_defs_32.h
index f12c75c1..289ad764 100644
--- a/src/libtools/my_x11_defs_32.h
+++ b/src/libtools/my_x11_defs_32.h
@@ -887,6 +887,275 @@ typedef struct my_XDevice_32_s {
      ptr_t  classes;    //my_XInputClassInfo_t*
 } my_XDevice_32_t;
 
+typedef struct my_XDeviceKeyEvent_32_s
+{
+    int            type;
+    ulong_t        serial;
+    int            send_event;
+    ptr_t          display; //Display*
+    XID_32         window;
+    XID_32         deviceid;
+    XID_32         root;
+    XID_32         subwindow;
+    ulong_t        time;
+    int            x, y;
+    int            x_root;
+    int            y_root;
+    unsigned int   state;
+    unsigned int   keycode;
+    int            same_screen;
+    unsigned int   device_state;
+    unsigned char  axes_count;
+    unsigned char  first_axis;
+    int            axis_data[6];
+} my_XDeviceKeyEvent_32_t;
+typedef my_XDeviceKeyEvent_32_t my_XDeviceButtonEvent_32_t;
+typedef struct my_XDeviceMotionEvent_32_s
+{
+    int            type;
+    ulong_t        serial;
+    int            send_event;
+    ptr_t          display; //Display*
+    XID_32         window;
+    XID_32         deviceid;
+    XID_32         root;
+    XID_32         subwindow;
+    ulong_t        time;
+    int            x, y;
+    int            x_root;
+    int            y_root;
+    unsigned int   state;
+    char           is_hint;
+    int            same_screen;
+    unsigned int   device_state;
+    unsigned char  axes_count;
+    unsigned char  first_axis;
+    int            axis_data[6];
+} my_XDeviceMotionEvent_32_t;
+typedef struct my_XDeviceFocusChangeEvent_32_s
+{
+    int           type;
+    ulong_t       serial;
+    int           send_event;
+    ptr_t         display;  //Display*
+    XID_32        window;
+    XID_32        deviceid;
+    int           mode;
+    int           detail;
+    ulong_t       time;
+} my_XDeviceFocusChangeEvent_32_t;
+typedef struct my_XProximityNotifyEvent_32_s
+{
+    int            type;
+    ulong_t        serial;
+    int            send_event;
+    ptr_t          display; //Display*
+    XID_32         window;
+    XID_32         deviceid;
+    XID_32         root;
+    XID_32         subwindow;
+    ulong_t        time;
+    int            x, y;
+    int            x_root;
+    int            y_root;
+    unsigned int   state;
+    int            same_screen;
+    unsigned int   device_state;
+    unsigned char  axes_count;
+    unsigned char  first_axis;
+    int            axis_data[6];
+} my_XProximityNotifyEvent_32_t;
+typedef struct my_XDeviceStateNotifyEvent_32_s
+{
+    int           type;
+    ulong_t       serial;
+    int           send_event;
+    ptr_t         display;  //Display*
+    XID_32        window;
+    XID_32        deviceid;
+    ulong_t       time;
+    int           num_classes;
+    char	      data[64];
+} my_XDeviceStateNotifyEvent_32_t;
+typedef struct my_XDeviceMappingEvent_32_s
+{
+    int           type;
+    ulong_t       serial;
+    int           send_event;
+    ptr_t         display;
+    XID_32        window;
+    XID_32        deviceid;
+    ulong_t       time;
+    int           request;
+    int           first_keycode;
+    int           count;
+} my_XDeviceMappingEvent_32_t;
+typedef struct my_XChangeDeviceNotifyEvent_32_s
+{
+    int           type;
+    ulong_t       serial;
+    int           send_event;
+    ptr_t         display;
+    XID_32        window;
+    XID_32        deviceid;
+    ulong_t       time;
+    int           request;
+} my_XChangeDeviceNotifyEvent_32_t;
+typedef struct my_XDevicePresenceNotifyEvent_32_s
+{
+    int           type;
+    ulong_t       serial;
+    int           send_event;
+    ptr_t         display;
+    XID_32        window;
+    ulong_t       time;
+    int           devchange;
+    XID_32        deviceid;
+    XID_32        control;
+} my_XDevicePresenceNotifyEvent_32_t;
+typedef struct my_XDevicePropertyNotifyEvent_32_s
+{
+    int           type;
+    ulong_t       serial;
+    int           send_event;
+    ptr_t         display;
+    XID_32        window;
+    ulong_t       time;
+    XID_32        deviceid;
+    XID_32        atom;
+    int           state;
+} my_XDevicePropertyNotifyEvent_32_t;
+typedef struct my_XFixesSelectionNotifyEvent_32_s
+{
+    int     type;
+    ulong_t serial;
+    int     send_event;
+    ptr_t   display;
+    XID_32  window;
+    int     subtype;
+    ulong_t selection_timestamp;
+    XID_32  owner;
+    XID_32  selection;
+    ulong_t timestamp;
+} my_XFixesSelectionNotifyEvent_32_t;
+typedef struct my_XFixesCursorNotifyEvent_32_s
+{
+    int     type;
+    ulong_t serial;
+    int     send_event;
+    ptr_t   display;
+    XID_32  window;
+    int     subtype;
+    ulong_t cursor_serial;
+    ulong_t timestamp;
+    XID_32  cursor_name;
+} my_XFixesCursorNotifyEvent_32_t;
+
+typedef struct my_XRRScreenChangeNotifyEvent_32_s
+{
+    int         type;
+    ulong_t     serial;
+    int         send_event;
+    ptr_t       display;
+    XID_32      window;
+    XID_32      root;
+    ulong_t     timestamp;
+    ulong_t     config_timestamp;
+    uint16_t    size_index;
+    uint16_t    subpixel_order;
+    uint16_t    rotation;
+    int         width;
+    int         height;
+    int         mwidth;
+    int         mheight;
+} my_XRRScreenChangeNotifyEvent_32_t;
+typedef struct my_XRRNotifyEvent_32_s
+{
+    int     type;
+    ulong_t serial;
+    int     send_event;
+    ptr_t   display;
+    XID_32  window;
+    int     subtype;
+} my_XRRNotifyEvent_32_t;
+typedef struct my_XRROutputChangeNotifyEvent_32_s
+{
+    int         type;
+    ulong_t     serial;
+    int         send_event;
+    ptr_t       display;
+    XID_32      window;
+    int         subtype;
+    XID_32      output;
+    XID_32      crtc;
+    XID_32      mode;
+    uint16_t    rotation;
+    uint16_t    connection;
+    uint16_t    subpixel_order;
+} my_XRROutputChangeNotifyEvent_32_t;
+typedef struct my_XRRCrtcChangeNotifyEvent_32_s
+{
+    int             type;
+    ulong_t         serial;
+    int             send_event;
+    ptr_t           display;
+    XID_32          window;
+    int             subtype;
+    XID_32          crtc;
+    XID_32          mode;
+    uint16_t        rotation;
+    int             x, y;
+    unsigned int    width, height;
+} my_XRRCrtcChangeNotifyEvent_32_t;
+typedef struct my_XRROutputPropertyNotifyEvent_32_s
+{
+    int     type;
+    ulong_t serial;
+    int     send_event;
+    ptr_t   display;
+    XID_32  window;
+    int     subtype;
+    XID_32  output;
+    XID_32  property;
+    ulong_t timestamp;
+    int     state;
+} my_XRROutputPropertyNotifyEvent_32_t;
+typedef struct my_XRRProviderChangeNotifyEvent_32_s
+{
+    int             type;
+    ulong_t         serial;
+    int             send_event;
+    ptr_t           display;
+    XID_32          window;
+    int             subtype;
+    XID_32          provider;
+    ulong_t         timestamp;
+    unsigned int    current_role;
+} my_XRRProviderChangeNotifyEvent_32_t;
+typedef struct my_XRRProviderPropertyNotifyEvent_32_s
+{
+    int     type;
+    ulong_t serial;
+    int     send_event;
+    ptr_t   display;
+    XID_32  window;
+    int     subtype;
+    XID_32  provider;
+    XID_32  property;
+    ulong_t timestamp;
+    int     state;
+} my_XRRProviderPropertyNotifyEvent_32_t;
+typedef struct my_XRRResourceChangeNotifyEvent_32_s
+{
+    int     type;
+    ulong_t serial;
+    int     send_event;
+    ptr_t   display;
+    XID_32  window;
+    int     subtype;
+    ulong_t timestamp;
+} my_XRRResourceChangeNotifyEvent_32_t;
+
 typedef struct my_XcursorCursors_32_s {
     ptr_t      dpy;     //Display*
     int        ref;
diff --git a/src/libtools/my_x11_xevent.c b/src/libtools/my_x11_xevent.c
new file mode 100644
index 00000000..71cadc52
--- /dev/null
+++ b/src/libtools/my_x11_xevent.c
@@ -0,0 +1,1351 @@
+#include <stdint.h>
+#include <dlfcn.h>
+
+#include "debug.h"
+#include "box32context.h"
+#include "wrapper32.h"
+#include "library.h"
+#include "bridge.h"
+#include "librarian/library_private.h"
+#include "converter32.h"
+#include "my_x11_defs.h"
+#include "my_x11_defs_32.h"
+#include "my_x11_conv.h"
+
+typedef void(*convertXEvent_to_32)(my_XEvent_32_t* dst, my_XEvent_t* src);
+typedef void(*convertXEvent_to_64)(my_XEvent_t* dst, my_XEvent_32_t* src);
+
+typedef struct reg_event_s {
+    uint32_t event;
+    convertXEvent_to_32 to32;
+    convertXEvent_to_64 to64;
+} reg_event_t;
+typedef struct register_events_s {
+    void* id;
+    uint32_t start_event;
+    uint32_t end_event;
+    size_t n;
+    reg_event_t* events;
+    struct register_events_s* next;
+} register_events_t;
+
+static register_events_t* register_events_head = NULL;
+
+void convertXEvent(my_XEvent_32_t* dst, my_XEvent_t* src)
+{
+    if(!src->type) {
+        // This is an XErrorEvent, and it's different!
+        dst->xerror.type = src->xerror.type;
+        dst->xerror.display = to_ptrv(FindDisplay(src->xerror.display));
+        dst->xerror.resourceid = to_ulong(src->xerror.resourceid);
+        dst->xerror.serial = to_ulong(src->xerror.serial);
+        dst->xerror.error_code = src->xerror.error_code;
+        dst->xerror.request_code = src->xerror.request_code;
+        dst->xerror.minor_code = src->xerror.minor_code;
+        return;
+    }
+    // convert the XAnyEvent first, as it's a common set
+    int type = src->type;
+    dst->type = src->type;
+    dst->xany.serial = to_ulong(src->xany.serial);
+    dst->xany.send_event = src->xany.serial;
+    dst->xany.display = to_ptrv(FindDisplay(src->xany.display));
+    if(type!=XEVT_GenericEvent)
+        dst->xany.window = to_ulong(src->xany.window);
+    switch(type) {
+        case XEVT_KeyPress:
+        case XEVT_KeyRelease:
+            dst->xkey.root = to_ulong(src->xkey.root);
+            dst->xkey.subwindow = to_ulong(src->xkey.subwindow);
+            dst->xkey.time = to_ulong(src->xkey.time);
+            dst->xkey.x = src->xkey.x;
+            dst->xkey.y = src->xkey.y;
+            dst->xkey.x_root = src->xkey.x_root;
+            dst->xkey.y_root = src->xkey.y_root;
+            dst->xkey.state = src->xkey.state;
+            dst->xkey.keycode = src->xkey.keycode;
+            dst->xkey.same_screen = src->xkey.same_screen;
+            break;
+        case XEVT_ButtonPress:
+        case XEVT_ButtonRelease:
+            dst->xbutton.root = to_ulong(src->xbutton.root);
+            dst->xbutton.subwindow = to_ulong(src->xbutton.subwindow);
+            dst->xbutton.time = to_ulong(src->xbutton.time);
+            dst->xbutton.x = src->xbutton.x;
+            dst->xbutton.y = src->xbutton.y;
+            dst->xbutton.x_root = src->xbutton.x_root;
+            dst->xbutton.y_root = src->xbutton.y_root;
+            dst->xbutton.state = src->xbutton.state;
+            dst->xbutton.button = src->xbutton.button;
+            dst->xbutton.same_screen = src->xbutton.same_screen;
+            break;
+        case XEVT_MotionNotify:
+            dst->xmotion.root = to_ulong(src->xmotion.root);
+            dst->xmotion.subwindow = to_ulong(src->xmotion.subwindow);
+            dst->xmotion.time = to_ulong(src->xmotion.time);
+            dst->xmotion.x = src->xmotion.x;
+            dst->xmotion.y = src->xmotion.y;
+            dst->xmotion.x_root = src->xmotion.x_root;
+            dst->xmotion.y_root = src->xmotion.y_root;
+            dst->xmotion.state = src->xmotion.state;
+            dst->xmotion.is_hint = src->xmotion.is_hint;
+            dst->xmotion.same_screen = src->xmotion.same_screen;
+            break;
+        case XEVT_EnterNotify:
+        case XEVT_LeaveNotify:
+            dst->xcrossing.root = to_ulong(src->xcrossing.root);
+            dst->xcrossing.subwindow = to_ulong(src->xcrossing.subwindow);
+            dst->xcrossing.time = to_ulong(src->xcrossing.time);
+            dst->xcrossing.x = src->xcrossing.x;
+            dst->xcrossing.y = src->xcrossing.y;
+            dst->xcrossing.x_root = src->xcrossing.x_root;
+            dst->xcrossing.y_root = src->xcrossing.y_root;
+            dst->xcrossing.mode = src->xcrossing.mode;
+            dst->xcrossing.detail = src->xcrossing.detail;
+            dst->xcrossing.same_screen = src->xcrossing.same_screen;
+            dst->xcrossing.focus = src->xcrossing.focus;
+            dst->xcrossing.state = src->xcrossing.state;
+            break;
+        case XEVT_FocusIn:
+        case XEVT_FocusOut:
+            dst->xfocus.mode = src->xfocus.mode;
+            dst->xfocus.detail = src->xfocus.detail;
+            break;
+        case XEVT_KeymapNotify:
+            memcpy(dst->xkeymap.key_vector, src->xkeymap.key_vector, 32);
+            break;
+        case XEVT_Expose:
+            dst->xexpose.x = src->xexpose.x;
+            dst->xexpose.y = src->xexpose.y;
+            dst->xexpose.width = src->xexpose.width;
+            dst->xexpose.height = src->xexpose.height;
+            dst->xexpose.count = src->xexpose.count;
+            break;
+        case XEVT_GraphicsExpose:
+            dst->xgraphicsexpose.x = src->xgraphicsexpose.x;
+            dst->xgraphicsexpose.y = src->xgraphicsexpose.y;
+            dst->xgraphicsexpose.width = src->xgraphicsexpose.width;
+            dst->xgraphicsexpose.height = src->xgraphicsexpose.height;
+            dst->xgraphicsexpose.count = src->xgraphicsexpose.count;
+            dst->xgraphicsexpose.major_code = src->xgraphicsexpose.major_code;
+            dst->xgraphicsexpose.minor_code = src->xgraphicsexpose.minor_code;
+            break;
+        case XEVT_NoExpose:
+            dst->xnoexpose.major_code = src->xnoexpose.major_code;
+            dst->xnoexpose.minor_code = src->xnoexpose.minor_code;
+            break;
+        case XEVT_VisibilityNotify:
+            dst->xvisibility.state = src->xvisibility.state;
+            break;
+        case XEVT_CreateNotify:
+            dst->xcreatewindow.window = to_ulong(src->xcreatewindow.window);
+            dst->xcreatewindow.x = src->xcreatewindow.x;
+            dst->xcreatewindow.y = src->xcreatewindow.y;
+            dst->xcreatewindow.width = src->xcreatewindow.width;
+            dst->xcreatewindow.height = src->xcreatewindow.height;
+            dst->xcreatewindow.border_width = src->xcreatewindow.border_width;
+            dst->xcreatewindow.override_redirect = src->xcreatewindow.override_redirect;
+            break;
+        case XEVT_DestroyNotify:
+            dst->xdestroywindow.window = to_ulong(src->xdestroywindow.window);
+            break;
+        case XEVT_UnmapNotify:
+            dst->xunmap.window = to_ulong(src->xunmap.window);
+            dst->xunmap.from_configure = src->xunmap.from_configure;
+            break;
+        case XEVT_MapNotify:
+            dst->xmap.window = to_ulong(src->xmap.window);
+            dst->xmap.override_redirect = src->xmap.override_redirect;
+            break;
+        case XEVT_MapRequest:
+            dst->xmaprequest.window = to_ulong(src->xmaprequest.window);
+            break;
+        case XEVT_ReparentNotify:
+            dst->xreparent.window = to_ulong(src->xreparent.window);
+            dst->xreparent.parent = to_ulong(src->xreparent.parent);
+            dst->xreparent.x = src->xreparent.x;
+            dst->xreparent.y = src->xreparent.y;
+            dst->xreparent.override_redirect = src->xreparent.override_redirect;
+            break;
+        case XEVT_ConfigureNotify:
+            dst->xconfigure.window = to_ulong(src->xconfigure.window);
+            dst->xconfigure.x = src->xconfigure.x;
+            dst->xconfigure.y = src->xconfigure.y;
+            dst->xconfigure.width = src->xconfigure.width;
+            dst->xconfigure.height = src->xconfigure.height;
+            dst->xconfigure.border_width = src->xconfigure.border_width;
+            dst->xconfigure.above = to_ulong(src->xconfigure.above);
+            dst->xconfigure.override_redirect = src->xconfigure.override_redirect;
+            break;
+        case XEVT_ConfigureRequest:
+            dst->xconfigurerequest.window = to_ulong(src->xconfigurerequest.window);
+            dst->xconfigurerequest.x = src->xconfigurerequest.x;
+            dst->xconfigurerequest.y = src->xconfigurerequest.y;
+            dst->xconfigurerequest.width = src->xconfigurerequest.width;
+            dst->xconfigurerequest.height = src->xconfigurerequest.height;
+            dst->xconfigurerequest.border_width = src->xconfigurerequest.border_width;
+            dst->xconfigurerequest.above = to_ulong(src->xconfigurerequest.above);
+            dst->xconfigurerequest.detail = src->xconfigurerequest.detail;
+            dst->xconfigurerequest.value_mask = to_ulong(src->xconfigurerequest.value_mask);
+            break;
+        case XEVT_GravityNotify:
+            dst->xgravity.window = to_ulong(src->xgravity.window);
+            dst->xgravity.x = src->xgravity.x;
+            dst->xgravity.y = src->xgravity.y;
+            break;
+        case XEVT_ResizeRequest:
+            dst->xresizerequest.width = src->xresizerequest.width;
+            dst->xresizerequest.height = src->xresizerequest.height;
+            break;
+        case XEVT_CirculateNotify:
+            dst->xcirculate.window = to_ulong(src->xcirculate.window);
+            dst->xcirculate.place = src->xcirculate.place;
+            break;
+        case XEVT_CirculateRequest:
+            dst->xcirculaterequest.window = to_ulong(src->xcirculaterequest.window);
+            dst->xcirculaterequest.place = src->xcirculaterequest.place;
+            break;
+        case XEVT_PropertyNotify:
+            dst->xproperty.atom = to_ulong(src->xproperty.atom);
+            dst->xproperty.time = to_ulong(src->xproperty.time);
+            dst->xproperty.state = src->xproperty.state;
+            break;
+        case XEVT_SelectionClear:
+            dst->xselectionclear.selection = to_ulong(src->xselectionclear.selection);
+            dst->xselectionclear.time = to_ulong(src->xselectionclear.time);
+            break;
+        case XEVT_SelectionRequest:
+            dst->xselectionrequest.requestor = to_ulong(src->xselectionrequest.requestor);
+            dst->xselectionrequest.selection = to_ulong(src->xselectionrequest.selection);
+            dst->xselectionrequest.target = to_ulong(src->xselectionrequest.target);
+            dst->xselectionrequest.property = to_ulong(src->xselectionrequest.property);
+            dst->xselectionrequest.time = to_ulong(src->xselectionrequest.time);
+            break;
+        case XEVT_SelectionNotify:
+            dst->xselection.selection = to_ulong(src->xselection.selection);
+            dst->xselection.target = to_ulong(src->xselection.target);
+            dst->xselection.property = to_ulong(src->xselection.property);
+            dst->xselection.time = to_ulong(src->xselection.time);
+            break;
+        case XEVT_ColormapNotify:
+            dst->xcolormap.colormap = to_ulong(src->xcolormap.colormap);
+            dst->xcolormap.c_new = src->xcolormap.c_new;
+            dst->xcolormap.state = src->xcolormap.state;
+            break;
+        case XEVT_ClientMessage:
+            dst->xclient.message_type = to_ulong(src->xclient.message_type);
+            dst->xclient.format = src->xclient.format;
+            if(src->xclient.format==32)
+                for(int i=0; i<5; ++i) {
+                    if(((src->xclient.data.l[i]&0xffffffff80000000LL))==0xffffffff80000000LL)
+                        dst->xclient.data.l[i] = to_ulong(src->xclient.data.l[i]&0xffffffff);   // negative value...
+                    else
+                        dst->xclient.data.l[i] = to_ulong(src->xclient.data.l[i]);
+                }
+            else
+                memcpy(dst->xclient.data.b, src->xclient.data.b, 20);
+            break;
+        case XEVT_MappingNotify:
+            dst->xmapping.request = src->xmapping.request;
+            dst->xmapping.first_keycode = src->xmapping.first_keycode;
+            dst->xmapping.count = src->xmapping.count;
+            break;
+        case XEVT_GenericEvent:
+            dst->xcookie.extension = src->xcookie.extension;
+            dst->xcookie.evtype = src->xcookie.evtype;
+            dst->xcookie.cookie = src->xcookie.cookie;
+            dst->xcookie.data = to_ptrv_silent(src->xcookie.data);  // in case data are not initialized
+            break;
+        default:
+            register_events_t* head = register_events_head;
+            while(head) {
+                if(type>=head->start_event && type<=head->end_event) {
+                    for(int i=0; i<head->n; ++i)
+                        if(type==head->events[i].event) {
+                            head->events[i].to32(dst, src);
+                            return;
+                        }
+                }
+                head = head->next;
+            }
+            printf_log(LOG_INFO, "Warning, unsupported 32bits XEvent type=%d\n", type);
+    }
+}
+void unconvertXEvent(my_XEvent_t* dst, my_XEvent_32_t* src)
+{
+    if(!src->type) {
+        // This is an XErrorEvent, and it's different!
+        dst->xerror.type = src->xerror.type;
+        dst->xerror.display = getDisplay(from_ptrv(src->xerror.display));
+        dst->xerror.resourceid = from_ulong(src->xerror.resourceid);
+        dst->xerror.serial = from_ulong(src->xerror.serial);
+        dst->xerror.error_code = src->xerror.error_code;
+        dst->xerror.request_code = src->xerror.request_code;
+        dst->xerror.minor_code = src->xerror.minor_code;
+        return;
+    }
+    // convert the XAnyEvent first, as it's a common set
+    int type = src->type;
+    dst->type = src->type;
+    if(type!=XEVT_GenericEvent)
+        dst->xany.window = from_ulong(src->xany.window);
+    dst->xany.display = getDisplay(from_ptrv(src->xany.display));
+    dst->xany.send_event = src->xany.serial;
+    dst->xany.serial = from_ulong(src->xany.serial);
+    switch(type) {
+        case XEVT_KeyPress:
+        case XEVT_KeyRelease:
+            dst->xkey.root = from_ulong(src->xkey.root);
+            dst->xkey.subwindow = from_ulong(src->xkey.subwindow);
+            dst->xkey.time = from_ulong(src->xkey.time);
+            dst->xkey.x = src->xkey.x;
+            dst->xkey.y = src->xkey.y;
+            dst->xkey.x_root = src->xkey.x_root;
+            dst->xkey.y_root = src->xkey.y_root;
+            dst->xkey.state = src->xkey.state;
+            dst->xkey.keycode = src->xkey.keycode;
+            dst->xkey.same_screen = src->xkey.same_screen;
+            break;
+        case XEVT_ButtonPress:
+        case XEVT_ButtonRelease:
+            dst->xbutton.root = from_ulong(src->xbutton.root);
+            dst->xbutton.subwindow = from_ulong(src->xbutton.subwindow);
+            dst->xbutton.time = from_ulong(src->xbutton.time);
+            dst->xbutton.x = src->xbutton.x;
+            dst->xbutton.y = src->xbutton.y;
+            dst->xbutton.x_root = src->xbutton.x_root;
+            dst->xbutton.y_root = src->xbutton.y_root;
+            dst->xbutton.state = src->xbutton.state;
+            dst->xbutton.button = src->xbutton.button;
+            dst->xbutton.same_screen = src->xbutton.same_screen;
+            break;
+        case XEVT_MotionNotify:
+            dst->xmotion.root = from_ulong(src->xmotion.root);
+            dst->xmotion.subwindow = from_ulong(src->xmotion.subwindow);
+            dst->xmotion.time = from_ulong(src->xmotion.time);
+            dst->xmotion.x = src->xmotion.x;
+            dst->xmotion.y = src->xmotion.y;
+            dst->xmotion.x_root = src->xmotion.x_root;
+            dst->xmotion.y_root = src->xmotion.y_root;
+            dst->xmotion.state = src->xmotion.state;
+            dst->xmotion.is_hint = src->xmotion.is_hint;
+            dst->xmotion.same_screen = src->xmotion.same_screen;
+            break;
+        case XEVT_EnterNotify:
+        case XEVT_LeaveNotify:
+            dst->xcrossing.root = from_ulong(src->xcrossing.root);
+            dst->xcrossing.subwindow = from_ulong(src->xcrossing.subwindow);
+            dst->xcrossing.time = from_ulong(src->xcrossing.time);
+            dst->xcrossing.x = src->xcrossing.x;
+            dst->xcrossing.y = src->xcrossing.y;
+            dst->xcrossing.x_root = src->xcrossing.x_root;
+            dst->xcrossing.y_root = src->xcrossing.y_root;
+            dst->xcrossing.mode = src->xcrossing.mode;
+            dst->xcrossing.detail = src->xcrossing.detail;
+            dst->xcrossing.same_screen = src->xcrossing.same_screen;
+            dst->xcrossing.focus = src->xcrossing.focus;
+            dst->xcrossing.state = src->xcrossing.state;
+            break;
+        case XEVT_FocusIn:
+        case XEVT_FocusOut:
+            dst->xfocus.mode = src->xfocus.mode;
+            dst->xfocus.detail = src->xfocus.detail;
+            break;
+        case XEVT_KeymapNotify:
+            memcpy(dst->xkeymap.key_vector, src->xkeymap.key_vector, 32);
+            break;
+        case XEVT_Expose:
+            dst->xexpose.x = src->xexpose.x;
+            dst->xexpose.y = src->xexpose.y;
+            dst->xexpose.width = src->xexpose.width;
+            dst->xexpose.height = src->xexpose.height;
+            dst->xexpose.count = src->xexpose.count;
+            break;
+        case XEVT_GraphicsExpose:
+            dst->xgraphicsexpose.x = src->xgraphicsexpose.x;
+            dst->xgraphicsexpose.y = src->xgraphicsexpose.y;
+            dst->xgraphicsexpose.width = src->xgraphicsexpose.width;
+            dst->xgraphicsexpose.height = src->xgraphicsexpose.height;
+            dst->xgraphicsexpose.count = src->xgraphicsexpose.count;
+            dst->xgraphicsexpose.major_code = src->xgraphicsexpose.major_code;
+            dst->xgraphicsexpose.minor_code = src->xgraphicsexpose.minor_code;
+            break;
+        case XEVT_NoExpose:
+            dst->xnoexpose.major_code = src->xnoexpose.major_code;
+            dst->xnoexpose.minor_code = src->xnoexpose.minor_code;
+            break;
+        case XEVT_VisibilityNotify:
+            dst->xvisibility.state = src->xvisibility.state;
+            break;
+        case XEVT_CreateNotify:
+            dst->xcreatewindow.window = from_ulong(src->xcreatewindow.window);
+            dst->xcreatewindow.x = src->xcreatewindow.x;
+            dst->xcreatewindow.y = src->xcreatewindow.y;
+            dst->xcreatewindow.width = src->xcreatewindow.width;
+            dst->xcreatewindow.height = src->xcreatewindow.height;
+            dst->xcreatewindow.border_width = src->xcreatewindow.border_width;
+            dst->xcreatewindow.override_redirect = src->xcreatewindow.override_redirect;
+            break;
+        case XEVT_DestroyNotify:
+            dst->xdestroywindow.window = from_ulong(src->xdestroywindow.window);
+            break;
+        case XEVT_UnmapNotify:
+            dst->xunmap.window = from_ulong(src->xunmap.window);
+            dst->xunmap.from_configure = src->xunmap.from_configure;
+            break;
+        case XEVT_MapNotify:
+            dst->xmap.window = from_ulong(src->xmap.window);
+            dst->xmap.override_redirect = src->xmap.override_redirect;
+            break;
+        case XEVT_MapRequest:
+            dst->xmaprequest.window = from_ulong(src->xmaprequest.window);
+            break;
+        case XEVT_ReparentNotify:
+            dst->xreparent.window = from_ulong(src->xreparent.window);
+            dst->xreparent.parent = from_ulong(src->xreparent.parent);
+            dst->xreparent.x = src->xreparent.x;
+            dst->xreparent.y = src->xreparent.y;
+            dst->xreparent.override_redirect = src->xreparent.override_redirect;
+            break;
+        case XEVT_ConfigureNotify:
+            dst->xconfigure.window = from_ulong(src->xconfigure.window);
+            dst->xconfigure.x = src->xconfigure.x;
+            dst->xconfigure.y = src->xconfigure.y;
+            dst->xconfigure.width = src->xconfigure.width;
+            dst->xconfigure.height = src->xconfigure.height;
+            dst->xconfigure.border_width = src->xconfigure.border_width;
+            dst->xconfigure.above = from_ulong(src->xconfigure.above);
+            dst->xconfigure.override_redirect = src->xconfigure.override_redirect;
+            break;
+        case XEVT_ConfigureRequest:
+            dst->xconfigurerequest.window = from_ulong(src->xconfigurerequest.window);
+            dst->xconfigurerequest.x = src->xconfigurerequest.x;
+            dst->xconfigurerequest.y = src->xconfigurerequest.y;
+            dst->xconfigurerequest.width = src->xconfigurerequest.width;
+            dst->xconfigurerequest.height = src->xconfigurerequest.height;
+            dst->xconfigurerequest.border_width = src->xconfigurerequest.border_width;
+            dst->xconfigurerequest.above = from_ulong(src->xconfigurerequest.above);
+            dst->xconfigurerequest.detail = src->xconfigurerequest.detail;
+            dst->xconfigurerequest.value_mask = from_ulong(src->xconfigurerequest.value_mask);
+            break;
+        case XEVT_GravityNotify:
+            dst->xgravity.window = from_ulong(src->xgravity.window);
+            dst->xgravity.x = src->xgravity.x;
+            dst->xgravity.y = src->xgravity.y;
+            break;
+        case XEVT_ResizeRequest:
+            dst->xresizerequest.width = src->xresizerequest.width;
+            dst->xresizerequest.height = src->xresizerequest.height;
+            break;
+        case XEVT_CirculateNotify:
+            dst->xcirculate.window = from_ulong(src->xcirculate.window);
+            dst->xcirculate.place = src->xcirculate.place;
+            break;
+        case XEVT_CirculateRequest:
+            dst->xcirculaterequest.window = from_ulong(src->xcirculaterequest.window);
+            dst->xcirculaterequest.place = src->xcirculaterequest.place;
+            break;
+        case XEVT_PropertyNotify:
+            dst->xproperty.atom = from_ulong(src->xproperty.atom);
+            dst->xproperty.time = from_ulong(src->xproperty.time);
+            dst->xproperty.state = src->xproperty.state;
+            break;
+        case XEVT_SelectionClear:
+            dst->xselectionclear.selection = from_ulong(src->xselectionclear.selection);
+            dst->xselectionclear.time = from_ulong(src->xselectionclear.time);
+            break;
+        case XEVT_SelectionRequest:
+            dst->xselectionrequest.requestor = from_ulong(src->xselectionrequest.requestor);
+            dst->xselectionrequest.selection = from_ulong(src->xselectionrequest.selection);
+            dst->xselectionrequest.target = from_ulong(src->xselectionrequest.target);
+            dst->xselectionrequest.property = from_ulong(src->xselectionrequest.property);
+            dst->xselectionrequest.time = from_ulong(src->xselectionrequest.time);
+            break;
+        case XEVT_SelectionNotify:
+            dst->xselection.selection = from_ulong(src->xselection.selection);
+            dst->xselection.target = from_ulong(src->xselection.target);
+            dst->xselection.property = from_ulong(src->xselection.property);
+            dst->xselection.time = from_ulong(src->xselection.time);
+            break;
+        case XEVT_ColormapNotify:
+            dst->xcolormap.colormap = from_ulong(src->xcolormap.colormap);
+            dst->xcolormap.c_new = src->xcolormap.c_new;
+            dst->xcolormap.state = src->xcolormap.state;
+            break;
+        case XEVT_ClientMessage:
+            dst->xclient.message_type = from_ulong(src->xclient.message_type);
+            dst->xclient.format = src->xclient.format;
+            if(src->xclient.format==32)
+                for(int i=0; i<5; ++i) dst->xclient.data.l[i] = from_ulong(src->xclient.data.l[i]);
+            else
+                memcpy(dst->xclient.data.b, src->xclient.data.b, 20);
+            break;
+        case XEVT_MappingNotify:
+            dst->xmapping.request = src->xmapping.request;
+            dst->xmapping.first_keycode = src->xmapping.first_keycode;
+            dst->xmapping.count = src->xmapping.count;
+            break;
+        case XEVT_GenericEvent:
+            dst->xcookie.extension = src->xcookie.extension;
+            dst->xcookie.evtype = src->xcookie.evtype;
+            dst->xcookie.cookie = src->xcookie.cookie;
+            dst->xcookie.data = from_ptrv(src->xcookie.data);
+            break;
+
+        default:
+            register_events_t* head = register_events_head;
+            while(head) {
+                if(type>=head->start_event && type<=head->end_event) {
+                    for(int i=0; i<head->n; ++i)
+                        if(type==head->events[i].event) {
+                            head->events[i].to64(dst, src);
+                            return;
+                        }
+                }
+                head = head->next;
+            }
+            printf_log(LOG_INFO, "Warning, unsupported 32bits (un)XEvent type=%d\n", type);
+    }
+}
+
+void convert_XErrorEvent_to_32(void* d, void* s)
+{
+    my_XErrorEvent_t* src = s;
+    my_XErrorEvent_32_t* dst = d;
+    dst->type = src->type;
+    dst->display = to_ptrv(FindDisplay(src->display));
+    dst->resourceid = to_ulong(src->resourceid);
+    dst->serial = to_ulong(src->serial);
+    dst->error_code = src->error_code;
+    dst->request_code = src->request_code;
+    dst->minor_code = src->minor_code;
+}
+void convert_XErrorEvent_to_64(void* d, void* s)
+{
+    my_XErrorEvent_32_t* src = s;
+    my_XErrorEvent_t* dst = d;
+    dst->minor_code = src->minor_code;
+    dst->request_code = src->request_code;
+    dst->error_code = src->error_code;
+    dst->serial = from_ulong(src->serial);
+    dst->resourceid = from_ulong(src->resourceid);
+    dst->display = getDisplay(from_ptrv(src->display));
+    dst->type = src->type;
+}
+
+void convert_XDeviceKeyEvent_to_32(my_XEvent_32_t* d, my_XEvent_t* s)
+{
+    my_XDeviceKeyEvent_t* src = (my_XDeviceKeyEvent_t*)s;
+    my_XDeviceKeyEvent_32_t* dst = (my_XDeviceKeyEvent_32_t*)d;
+
+    //dst->type = src->type;
+    //dst->serial = src->serial;
+    //dst->send_event = src->send_event;
+    //dst->display = src->display;
+    //dst->window = src->window;
+    dst->deviceid = to_ulong(src->deviceid);
+    dst->root = to_ulong(src->root);
+    dst->subwindow = to_ulong(src->subwindow);
+    dst->time = to_ulong(src->time);
+    dst->x = src->x;
+    dst->y = src->y;
+    dst->x_root = src->x_root;
+    dst->y_root = src->y_root;
+    dst->state = src->state;
+    dst->keycode = src->keycode;
+    dst->same_screen = src->same_screen;
+    dst->device_state = src->device_state;
+    dst->axes_count = src->axes_count;
+    dst->first_axis = src->first_axis;
+    dst->axis_data[0] = src->axis_data[0];
+    dst->axis_data[1] = src->axis_data[1];
+    dst->axis_data[2] = src->axis_data[2];
+    dst->axis_data[3] = src->axis_data[3];
+    dst->axis_data[4] = src->axis_data[4];
+    dst->axis_data[5] = src->axis_data[5];
+}
+void convert_XDeviceKeyEvent_to_64(my_XEvent_t* d, my_XEvent_32_t* s)
+{
+    my_XDeviceKeyEvent_32_t* src = (my_XDeviceKeyEvent_32_t*)s;
+    my_XDeviceKeyEvent_t* dst = (my_XDeviceKeyEvent_t*)d;
+
+    dst->axis_data[5] = src->axis_data[5];
+    dst->axis_data[4] = src->axis_data[4];
+    dst->axis_data[3] = src->axis_data[3];
+    dst->axis_data[2] = src->axis_data[2];
+    dst->axis_data[1] = src->axis_data[1];
+    dst->axis_data[0] = src->axis_data[0];
+    dst->first_axis = src->first_axis;
+    dst->axes_count = src->axes_count;
+    dst->device_state = src->device_state;
+    dst->same_screen = src->same_screen;
+    dst->keycode = src->keycode;
+    dst->state = src->state;
+    dst->y_root = src->y_root;
+    dst->x_root = src->x_root;
+    dst->y = src->y;
+    dst->x = src->x;
+    dst->time = from_ulong(src->time);
+    dst->subwindow = from_ulong(src->subwindow);
+    dst->root = from_ulong(src->root);
+    dst->deviceid = from_ulong(src->deviceid);
+    //dst->window = src->window;
+    //dst->display = src->display;
+    //dst->send_event = src->send_event;
+    //dst->serial = src->serial;
+    //dst->type = src->type;
+}
+void convert_XDeviceMotionEvent_to_32(my_XEvent_32_t* d, my_XEvent_t* s)
+{
+    my_XDeviceMotionEvent_t* src = (my_XDeviceMotionEvent_t*)s;
+    my_XDeviceMotionEvent_32_t* dst = (my_XDeviceMotionEvent_32_t*)d;
+
+    //dst->type = src->type;
+    //dst->serial = src->serial;
+    //dst->send_event = src->send_event;
+    //dst->display = src->display;
+    //dst->window = src->window;
+    dst->deviceid = to_ulong(src->deviceid);
+    dst->root = to_ulong(src->root);
+    dst->subwindow = to_ulong(src->subwindow);
+    dst->time = to_ulong(src->time);
+    dst->x = src->x;
+    dst->y = src->y;
+    dst->x_root = src->x_root;
+    dst->y_root = src->y_root;
+    dst->state = src->state;
+    dst->is_hint = src->is_hint;
+    dst->same_screen = src->same_screen;
+    dst->device_state = src->device_state;
+    dst->axes_count = src->axes_count;
+    dst->first_axis = src->first_axis;
+    dst->axis_data[0] = src->axis_data[0];
+    dst->axis_data[1] = src->axis_data[1];
+    dst->axis_data[2] = src->axis_data[2];
+    dst->axis_data[3] = src->axis_data[3];
+    dst->axis_data[4] = src->axis_data[4];
+    dst->axis_data[5] = src->axis_data[5];
+}
+void convert_XDeviceMotionEvent_to_64(my_XEvent_t* d, my_XEvent_32_t* s)
+{
+    my_XDeviceMotionEvent_32_t* src = (my_XDeviceMotionEvent_32_t*)s;
+    my_XDeviceMotionEvent_t* dst = (my_XDeviceMotionEvent_t*)d;
+
+    dst->axis_data[5] = src->axis_data[5];
+    dst->axis_data[4] = src->axis_data[4];
+    dst->axis_data[3] = src->axis_data[3];
+    dst->axis_data[2] = src->axis_data[2];
+    dst->axis_data[1] = src->axis_data[1];
+    dst->axis_data[0] = src->axis_data[0];
+    dst->first_axis = src->first_axis;
+    dst->axes_count = src->axes_count;
+    dst->device_state = src->device_state;
+    dst->same_screen = src->same_screen;
+    dst->is_hint = src->is_hint;
+    dst->state = src->state;
+    dst->y_root = src->y_root;
+    dst->x_root = src->x_root;
+    dst->y = src->y;
+    dst->x = src->x;
+    dst->time = from_ulong(src->time);
+    dst->subwindow = from_ulong(src->subwindow);
+    dst->root = from_ulong(src->root);
+    dst->deviceid = from_ulong(src->deviceid);
+    //dst->window = src->window;
+    //dst->display = src->display;
+    //dst->send_event = src->send_event;
+    //dst->serial = src->serial;
+    //dst->type = src->type;
+}
+void convert_XDeviceFocusEvent_to_32(my_XEvent_32_t* d, my_XEvent_t* s)
+{
+    my_XDeviceFocusChangeEvent_t* src = (my_XDeviceFocusChangeEvent_t*)s;
+    my_XDeviceFocusChangeEvent_32_t* dst = (my_XDeviceFocusChangeEvent_32_t*)d;
+
+    //dst->type = src->type;
+    //dst->serial = src->serial;
+    //dst->send_event = src->send_event;
+    //dst->display = src->display;
+    //dst->window = src->window;
+    dst->deviceid = to_ulong(src->deviceid);
+    dst->mode = src->mode;
+    dst->detail = src->detail;
+    dst->time = to_ulong(src->time);
+}
+void convert_XDeviceFocusEvent_to_64(my_XEvent_t* d, my_XEvent_32_t* s)
+{
+    my_XDeviceFocusChangeEvent_32_t* src = (my_XDeviceFocusChangeEvent_32_t*)s;
+    my_XDeviceFocusChangeEvent_t* dst = (my_XDeviceFocusChangeEvent_t*)d;
+
+    dst->time = from_ulong(src->time);
+    dst->detail = src->detail;
+    dst->mode = src->mode;
+    dst->deviceid = from_ulong(src->deviceid);
+    //dst->window = src->window;
+    //dst->display = src->display;
+    //dst->send_event = src->send_event;
+    //dst->serial = src->serial;
+    //dst->type = src->type;
+}
+void convert_XProximityNotifyEvent_to_32(my_XEvent_32_t* d, my_XEvent_t* s)
+{
+    my_XProximityNotifyEvent_t* src = (my_XProximityNotifyEvent_t*)s;
+    my_XProximityNotifyEvent_32_t* dst = (my_XProximityNotifyEvent_32_t*)d;
+
+    //dst->type = src->type;
+    //dst->serial = src->serial;
+    //dst->send_event = src->send_event;
+    //dst->display = src->display;
+    //dst->window = src->window;
+    dst->deviceid = to_ulong(src->deviceid);
+    dst->root = to_ulong(src->root);
+    dst->subwindow = to_ulong(src->subwindow);
+    dst->time = to_ulong(src->time);
+    dst->x = src->x;
+    dst->y = src->y;
+    dst->x_root = src->x_root;
+    dst->y_root = src->y_root;
+    dst->state = src->state;
+    dst->same_screen = src->same_screen;
+    dst->device_state = src->device_state;
+    dst->axes_count = src->axes_count;
+    dst->first_axis = src->first_axis;
+    dst->axis_data[0] = src->axis_data[0];
+    dst->axis_data[1] = src->axis_data[1];
+    dst->axis_data[2] = src->axis_data[2];
+    dst->axis_data[3] = src->axis_data[3];
+    dst->axis_data[4] = src->axis_data[4];
+    dst->axis_data[5] = src->axis_data[5];
+}
+void convert_XProximityNotifyEvent_to_64(my_XEvent_t* d, my_XEvent_32_t* s)
+{
+    my_XProximityNotifyEvent_32_t* src = (my_XProximityNotifyEvent_32_t*)s;
+    my_XProximityNotifyEvent_t* dst = (my_XProximityNotifyEvent_t*)d;
+
+    dst->axis_data[5] = src->axis_data[5];
+    dst->axis_data[4] = src->axis_data[4];
+    dst->axis_data[3] = src->axis_data[3];
+    dst->axis_data[2] = src->axis_data[2];
+    dst->axis_data[1] = src->axis_data[1];
+    dst->axis_data[0] = src->axis_data[0];
+    dst->first_axis = src->first_axis;
+    dst->axes_count = src->axes_count;
+    dst->device_state = src->device_state;
+    dst->same_screen = src->same_screen;
+    dst->state = src->state;
+    dst->y_root = src->y_root;
+    dst->x_root = src->x_root;
+    dst->y = src->y;
+    dst->x = src->x;
+    dst->time = from_ulong(src->time);
+    dst->subwindow = from_ulong(src->subwindow);
+    dst->root = from_ulong(src->root);
+    dst->deviceid = from_ulong(src->deviceid);
+    //dst->window = src->window;
+    //dst->display = src->display;
+    //dst->send_event = src->send_event;
+    //dst->serial = src->serial;
+    //dst->type = src->type;
+}
+void convert_XDeviceStateNotifyEvent_to_32(my_XEvent_32_t* d, my_XEvent_t* s)
+{
+    my_XDeviceStateNotifyEvent_t* src = (my_XDeviceStateNotifyEvent_t*)s;
+    my_XDeviceStateNotifyEvent_32_t* dst = (my_XDeviceStateNotifyEvent_32_t*)d;
+
+    //dst->type = src->type;
+    //dst->serial = src->serial;
+    //dst->send_event = src->send_event;
+    //dst->display = src->display;
+    //dst->window = src->window;
+    dst->deviceid = to_ulong(src->deviceid);
+    dst->time = to_ulong(src->time);
+    memmove(dst->data, src->data, 64);
+}
+void convert_XDeviceStateNotifyEvent_to_64(my_XEvent_t* d, my_XEvent_32_t* s)
+{
+    my_XDeviceStateNotifyEvent_32_t* src = (my_XDeviceStateNotifyEvent_32_t*)s;
+    my_XDeviceStateNotifyEvent_t* dst = (my_XDeviceStateNotifyEvent_t*)d;
+
+    memmove(dst->data, src->data, 64);
+    dst->time = from_ulong(src->time);
+    dst->deviceid = from_ulong(src->deviceid);
+    //dst->window = src->window;
+    //dst->display = src->display;
+    //dst->send_event = src->send_event;
+    //dst->serial = src->serial;
+    //dst->type = src->type;
+}
+void convert_XDeviceMappingEvent_to_32(my_XEvent_32_t* d, my_XEvent_t* s)
+{
+    my_XDeviceMappingEvent_t* src = (my_XDeviceMappingEvent_t*)s;
+    my_XDeviceMappingEvent_32_t* dst = (my_XDeviceMappingEvent_32_t*)d;
+
+    //dst->type = src->type;
+    //dst->serial = src->serial;
+    //dst->send_event = src->send_event;
+    //dst->display = src->display;
+    //dst->window = src->window;
+    dst->deviceid = to_ulong(src->deviceid);
+    dst->time = to_ulong(src->time);
+    dst->request = src->request;
+    dst->first_keycode = src->first_keycode;
+    dst->count = src->count;
+}
+void convert_XDeviceMappingEvent_to_64(my_XEvent_t* d, my_XEvent_32_t* s)
+{
+    my_XDeviceMappingEvent_32_t* src = (my_XDeviceMappingEvent_32_t*)s;
+    my_XDeviceMappingEvent_t* dst = (my_XDeviceMappingEvent_t*)d;
+
+    dst->count = src->count;
+    dst->first_keycode = src->first_keycode;
+    dst->request = src->request;
+    dst->time = from_ulong(src->time);
+    dst->deviceid = from_ulong(src->deviceid);
+    //dst->window = src->window;
+    //dst->display = src->display;
+    //dst->send_event = src->send_event;
+    //dst->serial = src->serial;
+    //dst->type = src->type;
+}
+void convert_XChangeDeviceNotifyEvent_to_32(my_XEvent_32_t* d, my_XEvent_t* s)
+{
+    my_XChangeDeviceNotifyEvent_t* src = (my_XChangeDeviceNotifyEvent_t*)s;
+    my_XChangeDeviceNotifyEvent_32_t* dst = (my_XChangeDeviceNotifyEvent_32_t*)d;
+
+    //dst->type = src->type;
+    //dst->serial = src->serial;
+    //dst->send_event = src->send_event;
+    //dst->display = src->display;
+    //dst->window = src->window;
+    dst->deviceid = to_ulong(src->deviceid);
+    dst->time = to_ulong(src->time);
+    dst->request = src->request;
+}
+void convert_XChangeDeviceNotifyEvent_to_64(my_XEvent_t* d, my_XEvent_32_t* s)
+{
+    my_XChangeDeviceNotifyEvent_32_t* src = (my_XChangeDeviceNotifyEvent_32_t*)s;
+    my_XChangeDeviceNotifyEvent_t* dst = (my_XChangeDeviceNotifyEvent_t*)d;
+
+    dst->request = src->request;
+    dst->time = from_ulong(src->time);
+    dst->deviceid = from_ulong(src->deviceid);
+    //dst->window = src->window;
+    //dst->display = src->display;
+    //dst->send_event = src->send_event;
+    //dst->serial = src->serial;
+    //dst->type = src->type;
+}
+void convert_XDevicePresenceNotifyEvent_to_32(my_XEvent_32_t* d, my_XEvent_t* s)
+{
+    my_XDevicePresenceNotifyEvent_t* src = (my_XDevicePresenceNotifyEvent_t*)s;
+    my_XDevicePresenceNotifyEvent_32_t* dst = (my_XDevicePresenceNotifyEvent_32_t*)d;
+
+    //dst->type = src->type;
+    //dst->serial = src->serial;
+    //dst->send_event = src->send_event;
+    //dst->display = src->display;
+    //dst->window = src->window;
+    dst->time = to_ulong(src->time);
+    dst->devchange = src->devchange;
+    dst->deviceid = to_ulong(src->deviceid);
+    dst->control = to_ulong(src->control);
+}
+void convert_XDevicePresenceNotifyEvent_to_64(my_XEvent_t* d, my_XEvent_32_t* s)
+{
+    my_XDevicePresenceNotifyEvent_32_t* src = (my_XDevicePresenceNotifyEvent_32_t*)s;
+    my_XDevicePresenceNotifyEvent_t* dst = (my_XDevicePresenceNotifyEvent_t*)d;
+
+    dst->control = from_ulong(src->control);
+    dst->deviceid = from_ulong(src->deviceid);
+    dst->devchange = src->devchange;
+    dst->time = from_ulong(src->time);
+    //dst->window = src->window;
+    //dst->display = src->display;
+    //dst->send_event = src->send_event;
+    //dst->serial = src->serial;
+    //dst->type = src->type;
+}
+void convert_XDevicePropertyNotifyEvent_to_32(my_XEvent_32_t* d, my_XEvent_t* s)
+{
+    my_XDevicePropertyNotifyEvent_t* src = (my_XDevicePropertyNotifyEvent_t*)s;
+    my_XDevicePropertyNotifyEvent_32_t* dst = (my_XDevicePropertyNotifyEvent_32_t*)d;
+
+    //dst->type = src->type;
+    //dst->serial = src->serial;
+    //dst->send_event = src->send_event;
+    //dst->display = src->display;
+    //dst->window = src->window;
+    dst->time = to_ulong(src->time);
+    dst->deviceid = to_ulong(src->deviceid);
+    dst->atom = to_ulong(src->atom);
+    dst->state = src->state;
+}
+void convert_XDevicePropertyNotifyEvent_to_64(my_XEvent_t* d, my_XEvent_32_t* s)
+{
+    my_XDevicePropertyNotifyEvent_32_t* src = (my_XDevicePropertyNotifyEvent_32_t*)s;
+    my_XDevicePropertyNotifyEvent_t* dst = (my_XDevicePropertyNotifyEvent_t*)d;
+
+    dst->state = src->state;
+    dst->atom = from_ulong(src->atom);
+    dst->deviceid = from_ulong(src->deviceid);
+    dst->time = from_ulong(src->time);
+    //dst->window = src->window;
+    //dst->display = src->display;
+    //dst->send_event = src->send_event;
+    //dst->serial = src->serial;
+    //dst->type = src->type;
+}
+void register_XDevice_events(my_XDevice_t* a)
+{
+    if(!a) return;
+    // search if device is already in list
+    register_events_t* head = register_events_head;
+    while(head) {
+        if(head->id == a)
+            return; // found, nothing to do....
+        head = head->next;
+    }
+    // counts events
+    int n=0;
+    for(int i=0; i<a->num_classes; ++i)
+        switch(a->classes[i].input_class) {
+            case 0: n+=2; break; //KeyClass
+            case 1: n+=2; break; //ButtonClass
+            case 2: n+=1; break; //ValuatorClass
+            case 5: n+=2; break; //FocusClass
+            case 4: n+=2; break; //ProximityClass
+            case 6: n+=4; break; //OtherClass
+        }
+    // check if there is something to notify
+    if(!n) return;
+    // create a new event list
+    register_events_t* events = box_malloc(sizeof(register_events_t)+n*sizeof(reg_event_t));
+    events->id = a;
+    events->n = n;
+    events->events = (reg_event_t*)(events+1);
+    n = 0;
+    for(int i=0; i<a->num_classes; ++i) {
+        switch(a->classes[i].input_class) {
+            case 0: //KeyClass
+                events->events[n].event = a->classes[i].event_type_base+0;
+                events->events[n].to32 = convert_XDeviceKeyEvent_to_32;
+                events->events[n].to64 = convert_XDeviceKeyEvent_to_64;
+                ++n;
+                events->events[n].event = a->classes[i].event_type_base+1;
+                events->events[n].to32 = convert_XDeviceKeyEvent_to_32;
+                events->events[n].to64 = convert_XDeviceKeyEvent_to_64;
+                ++n;
+                break;  
+            case 1: //ButtonClass
+                events->events[n].event = a->classes[i].event_type_base+0;
+                events->events[n].to32 = convert_XDeviceKeyEvent_to_32;
+                events->events[n].to64 = convert_XDeviceKeyEvent_to_64;
+                ++n;
+                events->events[n].event = a->classes[i].event_type_base+1;
+                events->events[n].to32 = convert_XDeviceKeyEvent_to_32;
+                events->events[n].to64 = convert_XDeviceKeyEvent_to_64;
+                ++n;
+                break;
+            case 2: //ValuatorClass
+                events->events[n].event = a->classes[i].event_type_base+0;
+                events->events[n].to32 = convert_XDeviceMotionEvent_to_32;
+                events->events[n].to64 = convert_XDeviceMotionEvent_to_64;
+                ++n;
+                break;
+            case 5: //FocusClass
+                events->events[n].event = a->classes[i].event_type_base+0;
+                events->events[n].to32 = convert_XDeviceFocusEvent_to_32;
+                events->events[n].to64 = convert_XDeviceFocusEvent_to_64;
+                ++n;
+                events->events[n].event = a->classes[i].event_type_base+1;
+                events->events[n].to32 = convert_XDeviceFocusEvent_to_32;
+                events->events[n].to64 = convert_XDeviceFocusEvent_to_64;
+                ++n;
+                break;
+            case 4: //ProximityClass
+                events->events[n].event = a->classes[i].event_type_base+0;
+                events->events[n].to32 = convert_XProximityNotifyEvent_to_32;
+                events->events[n].to64 = convert_XProximityNotifyEvent_to_64;
+                ++n;
+                events->events[n].event = a->classes[i].event_type_base+1;
+                events->events[n].to32 = convert_XProximityNotifyEvent_to_32;
+                events->events[n].to64 = convert_XProximityNotifyEvent_to_64;
+                ++n;
+                break;
+            case 6: //OtherClass
+                events->events[n].event = a->classes[i].event_type_base+0;
+                events->events[n].to32 = convert_XDeviceStateNotifyEvent_to_32;
+                events->events[n].to64 = convert_XDeviceStateNotifyEvent_to_64;
+                ++n;
+                events->events[n].event = a->classes[i].event_type_base+1;
+                events->events[n].to32 = convert_XDeviceMappingEvent_to_32;
+                events->events[n].to64 = convert_XDeviceMappingEvent_to_64;
+                ++n;
+                events->events[n].event = a->classes[i].event_type_base+2;
+                events->events[n].to32 = convert_XChangeDeviceNotifyEvent_to_32;
+                events->events[n].to64 = convert_XChangeDeviceNotifyEvent_to_64;
+                ++n;
+                //+3 would be DeviceKeyStateNotify
+                //+4 wpuld be DeviceButtonStateNotify
+                //+5 would be DevicePresenceNotify
+                events->events[n].event = a->classes[i].event_type_base+6;
+                events->events[n].to32 = convert_XDevicePropertyNotifyEvent_to_32;
+                events->events[n].to64 = convert_XDevicePropertyNotifyEvent_to_64;
+                ++n;
+                break;
+        }
+    }
+    events->start_event = events->end_event = events->events[0].event;
+    for(int i=1; i<n; ++i) {
+        if(events->start_event>events->events[i].event) events->start_event = events->events[i].event;
+        if(events->end_event<events->events[i].event) events->end_event = events->events[i].event;
+    }
+    events->next = register_events_head;
+    register_events_head = events;
+}
+void unregister_XDevice_events(my_XDevice_t* a)
+{
+    if(!a) return;
+    register_events_t* prev = NULL;
+    register_events_t* head = register_events_head;
+    while(head) {
+        if(head->id == a) {
+            if(!prev)
+                register_events_head = head->next;
+            else
+                prev->next = head->next;
+            box_free(head);
+            return;
+        }
+        prev = head;
+        head = head->next;
+    }
+}
+
+void convert_XFixesSelectionNotifyEvent_to_32(my_XEvent_32_t* d, my_XEvent_t* s)
+{
+    my_XFixesSelectionNotifyEvent_t* src = (my_XFixesSelectionNotifyEvent_t*)s;
+    my_XFixesSelectionNotifyEvent_32_t* dst = (my_XFixesSelectionNotifyEvent_32_t*)d;
+
+    //dst->type = src->type;
+    //dst->serial = src->serial;
+    //dst->send_event = src->send_event;
+    //dst->display = src->display;
+    //dst->window = src->window;
+    dst->subtype = src->subtype;
+    dst->owner = to_ulong(src->owner);
+    dst->selection = to_ulong(src->selection);
+    dst->timestamp = to_ulong(src->timestamp);
+    dst->selection_timestamp = to_ulong(src->selection_timestamp);
+}
+void convert_XFixesSelectionNotifyEvent_to_64(my_XEvent_t* d, my_XEvent_32_t* s)
+{
+    my_XFixesSelectionNotifyEvent_32_t* src = (my_XFixesSelectionNotifyEvent_32_t*)s;
+    my_XFixesSelectionNotifyEvent_t* dst = (my_XFixesSelectionNotifyEvent_t*)d;
+
+    dst->selection_timestamp = from_ulong(src->selection_timestamp);
+    dst->timestamp = from_ulong(src->timestamp);
+    dst->selection = from_ulong(src->selection);
+    dst->owner = from_ulong(src->owner);
+    dst->subtype = src->subtype;
+    //dst->window = src->window;
+    //dst->display = src->display;
+    //dst->send_event = src->send_event;
+    //dst->serial = src->serial;
+    //dst->type = src->type;
+}
+void convert_XFixesCursorNotifyEvent_to_32(my_XEvent_32_t* d, my_XEvent_t* s)
+{
+    my_XFixesCursorNotifyEvent_t* src = (my_XFixesCursorNotifyEvent_t*)s;
+    my_XFixesCursorNotifyEvent_32_t* dst = (my_XFixesCursorNotifyEvent_32_t*)d;
+
+    //dst->type = src->type;
+    //dst->serial = src->serial;
+    //dst->send_event = src->send_event;
+    //dst->display = src->display;
+    //dst->window = src->window;
+    dst->subtype = src->subtype;
+    dst->cursor_serial = to_ulong(src->cursor_serial);
+    dst->timestamp = to_ulong(src->timestamp);
+    dst->cursor_name = to_ulong(src->cursor_name);
+}
+void convert_XFixesCursorNotifyEvent_to_64(my_XEvent_t* d, my_XEvent_32_t* s)
+{
+    my_XFixesCursorNotifyEvent_32_t* src = (my_XFixesCursorNotifyEvent_32_t*)s;
+    my_XFixesCursorNotifyEvent_t* dst = (my_XFixesCursorNotifyEvent_t*)d;
+
+    dst->cursor_serial = from_ulong(src->cursor_serial);
+    dst->timestamp = from_ulong(src->timestamp);
+    dst->cursor_name = from_ulong(src->cursor_name);
+    dst->subtype = src->subtype;
+    //dst->window = src->window;
+    //dst->display = src->display;
+    //dst->send_event = src->send_event;
+    //dst->serial = src->serial;
+    //dst->type = src->type;
+}
+
+void register_XFixes_events(int event_base)
+{
+    void* a = (void*)1LL;
+    // search if device is already in list
+    register_events_t* head = register_events_head;
+    while(head) {
+        if(head->id == a)
+            return; // found, nothing to do....
+        head = head->next;
+    }
+    int n = 2;  // 2 events to register!
+    // create a new event list
+    register_events_t* events = box_malloc(sizeof(register_events_t)+n*sizeof(reg_event_t));
+    events->id = a;
+    events->n = n;
+    events->events = (reg_event_t*)(events+1);
+
+    events->events[0].event = event_base+0;
+    events->events[0].to32 = convert_XFixesSelectionNotifyEvent_to_32;
+    events->events[0].to64 = convert_XFixesSelectionNotifyEvent_to_64;
+    events->events[1].event = event_base+1;
+    events->events[1].to32 = convert_XFixesCursorNotifyEvent_to_32;
+    events->events[1].to64 = convert_XFixesCursorNotifyEvent_to_64;
+
+    events->start_event = events->end_event = events->events[0].event;
+    events->next = register_events_head;
+    register_events_head = events;
+}
+void unregister_XFixes_events()
+{
+    void* a = (void*)1LL;
+    register_events_t* prev = NULL;
+    register_events_t* head = register_events_head;
+    while(head) {
+        if(head->id == a) {
+            if(!prev)
+                register_events_head = head->next;
+            else
+                prev->next = head->next;
+            box_free(head);
+            return;
+        }
+        prev = head;
+        head = head->next;
+    }
+}
+
+void convert_XRRScreenChangeNotifyEvent_to_32(my_XEvent_32_t* d, my_XEvent_t* s)
+{
+    my_XRRScreenChangeNotifyEvent_t* src = (my_XRRScreenChangeNotifyEvent_t*)s;
+    my_XRRScreenChangeNotifyEvent_32_t* dst = (my_XRRScreenChangeNotifyEvent_32_t*)d;
+
+    //dst->type = src->type;
+    //dst->serial = src->serial;
+    //dst->send_event = src->send_event;
+    //dst->display = src->display;
+    //dst->window = src->window;
+    dst->root = to_ulong(src->root);
+    dst->timestamp = to_ulong(src->timestamp);
+    dst->config_timestamp = to_ulong(src->config_timestamp);
+    dst->size_index = src->size_index;
+    dst->subpixel_order = src->subpixel_order;
+    dst->rotation = src->rotation;
+    dst->width = src->width;
+    dst->height = src->height;
+    dst->mwidth = src->mwidth;
+    dst->mheight = src->mheight;
+}
+void convert_XRRScreenChangeNotifyEvent_to_64(my_XEvent_t* d, my_XEvent_32_t* s)
+{
+    my_XRRScreenChangeNotifyEvent_32_t* src = (my_XRRScreenChangeNotifyEvent_32_t*)s;
+    my_XRRScreenChangeNotifyEvent_t* dst = (my_XRRScreenChangeNotifyEvent_t*)d;
+
+    dst->mheight = src->mheight;
+    dst->mwidth = src->mwidth;
+    dst->height = src->height;
+    dst->width = src->width;
+    dst->rotation = src->rotation;
+    dst->subpixel_order = src->subpixel_order;
+    dst->size_index = src->size_index;
+    dst->config_timestamp = from_ulong(src->config_timestamp);
+    dst->timestamp = from_ulong(src->timestamp);
+    dst->root = from_ulong(src->root);
+    //dst->window = src->window;
+    //dst->display = src->display;
+    //dst->send_event = src->send_event;
+    //dst->serial = src->serial;
+    //dst->type = src->type;
+}
+void convert_XRRNotifyEvent_to_32(my_XEvent_32_t* d, my_XEvent_t* s)
+{
+    my_XRRNotifyEvent_t* src = (my_XRRNotifyEvent_t*)s;
+    my_XRRNotifyEvent_32_t* dst = (my_XRRNotifyEvent_32_t*)d;
+
+    //dst->type = src->type;
+    //dst->serial = src->serial;
+    //dst->send_event = src->send_event;
+    //dst->display = src->display;
+    //dst->window = src->window;
+    int subtype = src->subtype;
+    dst->subtype = src->subtype;
+    switch (subtype) {
+        case 0: {
+            my_XRROutputChangeNotifyEvent_t* src = (my_XRROutputChangeNotifyEvent_t*)s;
+            my_XRROutputChangeNotifyEvent_32_t* dst = (my_XRROutputChangeNotifyEvent_32_t*)d;
+            dst->output = to_long(src->output);
+            dst->crtc = to_long(src->crtc);
+            dst->mode = to_long(src->mode);
+            dst->rotation = src->rotation;
+            dst->connection = src->connection;
+            dst->subpixel_order = src->subpixel_order;
+        } break;
+        case 1: {
+            my_XRRCrtcChangeNotifyEvent_t* src = (my_XRRCrtcChangeNotifyEvent_t*)s;
+            my_XRRCrtcChangeNotifyEvent_32_t* dst = (my_XRRCrtcChangeNotifyEvent_32_t*)d;
+            dst->crtc = to_ulong(src->crtc);
+            dst->mode = to_ulong(src->mode);
+            dst->rotation = src->rotation;
+            dst->x = src->x;
+            dst->y = src->y;
+            dst->width = src->width;
+            dst->height = src->height;
+        } break;
+        case 2: {
+            my_XRROutputPropertyNotifyEvent_t* src = (my_XRROutputPropertyNotifyEvent_t*)s;
+            my_XRROutputPropertyNotifyEvent_32_t* dst = (my_XRROutputPropertyNotifyEvent_32_t*)d;
+            dst->output = to_ulong(src->output);
+            dst->property = to_ulong(src->property);
+            dst->timestamp = to_ulong(src->timestamp);
+            dst->state = src->state;
+        } break;
+        case 3: {
+            my_XRRProviderChangeNotifyEvent_t* src = (my_XRRProviderChangeNotifyEvent_t*)s;
+            my_XRRProviderChangeNotifyEvent_32_t* dst = (my_XRRProviderChangeNotifyEvent_32_t*)d;
+            dst->provider = to_ulong(src->provider);
+            dst->timestamp = to_ulong(src->timestamp);
+            dst->current_role = src->current_role;
+        } break;
+        case 4: {
+            my_XRRProviderPropertyNotifyEvent_t* src = (my_XRRProviderPropertyNotifyEvent_t*)s;
+            my_XRRProviderPropertyNotifyEvent_32_t* dst = (my_XRRProviderPropertyNotifyEvent_32_t*)d;
+            dst->provider = to_ulong(src->provider);
+            dst->property = to_ulong(src->property);
+            dst->timestamp = to_ulong(src->timestamp);
+            dst->state = src->state;
+        } break;
+        case 5: {
+            my_XRRResourceChangeNotifyEvent_t* src = (my_XRRResourceChangeNotifyEvent_t*)s;
+            my_XRRResourceChangeNotifyEvent_32_t* dst = (my_XRRResourceChangeNotifyEvent_32_t*)d;
+            dst->timestamp = to_ulong(src->timestamp);
+        } break;
+    }
+}
+void convert_XRRNotifyEvent_to_64(my_XEvent_t* d, my_XEvent_32_t* s)
+{
+    my_XRRNotifyEvent_32_t* src = (my_XRRNotifyEvent_32_t*)s;
+    my_XRRNotifyEvent_t* dst = (my_XRRNotifyEvent_t*)d;
+    int subtype = src->subtype;
+    switch (subtype) {
+        case 0: {
+            my_XRROutputChangeNotifyEvent_32_t* src = (my_XRROutputChangeNotifyEvent_32_t*)s;
+            my_XRROutputChangeNotifyEvent_t* dst = (my_XRROutputChangeNotifyEvent_t*)d;
+            dst->output = from_long(src->output);
+            dst->crtc = from_long(src->crtc);
+            dst->mode = from_long(src->mode);
+            dst->rotation = src->rotation;
+            dst->connection = src->connection;
+            dst->subpixel_order = src->subpixel_order;
+        } break;
+        case 1: {
+            my_XRRCrtcChangeNotifyEvent_32_t* src = (my_XRRCrtcChangeNotifyEvent_32_t*)s;
+            my_XRRCrtcChangeNotifyEvent_t* dst = (my_XRRCrtcChangeNotifyEvent_t*)d;
+            dst->crtc = from_ulong(src->crtc);
+            dst->mode = from_ulong(src->mode);
+            dst->rotation = src->rotation;
+            dst->x = src->x;
+            dst->y = src->y;
+            dst->width = src->width;
+            dst->height = src->height;
+        } break;
+        case 2: {
+            my_XRROutputPropertyNotifyEvent_32_t* src = (my_XRROutputPropertyNotifyEvent_32_t*)s;
+            my_XRROutputPropertyNotifyEvent_t* dst = (my_XRROutputPropertyNotifyEvent_t*)d;
+            dst->output = from_ulong(src->output);
+            dst->property = from_ulong(src->property);
+            dst->timestamp = from_ulong(src->timestamp);
+            dst->state = src->state;
+        } break;
+        case 3: {
+            my_XRRProviderChangeNotifyEvent_32_t* src = (my_XRRProviderChangeNotifyEvent_32_t*)s;
+            my_XRRProviderChangeNotifyEvent_t* dst = (my_XRRProviderChangeNotifyEvent_t*)d;
+            dst->provider = from_ulong(src->provider);
+            dst->timestamp = from_ulong(src->timestamp);
+            dst->current_role = src->current_role;
+        } break;
+        case 4: {
+            my_XRRProviderPropertyNotifyEvent_32_t* src = (my_XRRProviderPropertyNotifyEvent_32_t*)s;
+            my_XRRProviderPropertyNotifyEvent_t* dst = (my_XRRProviderPropertyNotifyEvent_t*)d;
+            dst->provider = from_ulong(src->provider);
+            dst->property = from_ulong(src->property);
+            dst->timestamp = from_ulong(src->timestamp);
+            dst->state = src->state;
+        } break;
+        case 5: {
+            my_XRRResourceChangeNotifyEvent_32_t* src = (my_XRRResourceChangeNotifyEvent_32_t*)s;
+            my_XRRResourceChangeNotifyEvent_t* dst = (my_XRRResourceChangeNotifyEvent_t*)d;
+            dst->timestamp = from_ulong(src->timestamp);
+        } break;
+    }
+    dst->subtype = src->subtype;
+    //dst->window = src->window;
+    //dst->display = src->display;
+    //dst->send_event = src->send_event;
+    //dst->serial = src->serial;
+    //dst->type = src->type;
+}
+
+void register_XRandR_events(int event_base)
+{
+    void* a = (void*)2LL;
+    // search if device is already in list
+    register_events_t* head = register_events_head;
+    while(head) {
+        if(head->id == a)
+            return; // found, nothing to do....
+        head = head->next;
+    }
+    int n = 2;  // 2 events to register!, but second one as 6+1 subtypes
+    // create a new event list
+    register_events_t* events = box_malloc(sizeof(register_events_t)+n*sizeof(reg_event_t));
+    events->id = a;
+    events->n = n;
+    events->events = (reg_event_t*)(events+1);
+
+    events->events[0].event = event_base+0;
+    events->events[0].to32 = convert_XRRScreenChangeNotifyEvent_to_32;
+    events->events[0].to64 = convert_XRRScreenChangeNotifyEvent_to_64;
+    events->events[1].event = event_base+1;
+    events->events[1].to32 = convert_XRRNotifyEvent_to_32;
+    events->events[1].to64 = convert_XRRNotifyEvent_to_64;
+
+    events->start_event = events->events[0].event;
+    events->end_event = events->events[1].event;
+    events->next = register_events_head;
+    register_events_head = events;
+}
+void unregister_XRandR_events()
+{
+    void* a = (void*)2LL;
+    register_events_t* prev = NULL;
+    register_events_t* head = register_events_head;
+    while(head) {
+        if(head->id == a) {
+            if(!prev)
+                register_events_head = head->next;
+            else
+                prev->next = head->next;
+            box_free(head);
+            return;
+        }
+        prev = head;
+        head = head->next;
+    }
+}
diff --git a/src/libtools/myalign32.c b/src/libtools/myalign32.c
index e47167d9..d16b8f28 100755
--- a/src/libtools/myalign32.c
+++ b/src/libtools/myalign32.c
@@ -351,13 +351,13 @@ void myStackAlignScanf32_final(const char* fmt, uint32_t* st, uint64_t* mystack,
                     ++conv;
                     if((state==22) || (state==25)) {
                         long_t* dst = from_ptrv(*st);
-                        *dst = to_long(saved[nb_elem-conv]);
+                        *dst = saved[nb_elem-conv]; // not using to_long on purpose
                     } else if(state==30) {
                         ptr_t* dst = from_ptrv(*st);
                         *dst = to_ptr(saved[nb_elem-conv]);
                     } else {
                         ulong_t* dst = from_ptrv(*st);
-                        *dst = to_ulong(saved[nb_elem-conv]);
+                        *dst = saved[nb_elem-conv]; //not using to to_ulong on pupose
                     }
                     ++st;
                     ++mystack;
diff --git a/src/wrapped32/generated/functions_list.txt b/src/wrapped32/generated/functions_list.txt
index 07bfddb8..a33d9a55 100644
--- a/src/wrapped32/generated/functions_list.txt
+++ b/src/wrapped32/generated/functions_list.txt
@@ -721,6 +721,7 @@
 #() iFEXip -> iFEXip
 #() iFEXlp -> iFEXlp
 #() iFEXLp -> iFEXLp
+#() iFEXpp -> iFEXpp
 #() iFiiii -> iFiiii
 #() iFiiiu -> iFiiiu
 #() iFiiip -> iFiiip
@@ -2153,6 +2154,8 @@ wrappedlibxext:
 - iFXLppiiiiuui:
   - XShmPutImage
 wrappedlibxfixes:
+- iFXpp:
+  - XFixesQueryExtension
 wrappedlibxi:
 - vFp:
   - XIFreeDeviceInfo
@@ -2176,6 +2179,8 @@ wrappedlibxrandr:
   - XRRGetProviderResources
   - XRRGetScreenResources
   - XRRGetScreenResourcesCurrent
+- iFXpp:
+  - XRRQueryExtension
 - pFXLL:
   - XRRQueryOutputProperty
 - pFXLp:
diff --git a/src/wrapped32/generated/wrappedlibxfixestypes32.h b/src/wrapped32/generated/wrappedlibxfixestypes32.h
index 349ec13c..3dde4e94 100644
--- a/src/wrapped32/generated/wrappedlibxfixestypes32.h
+++ b/src/wrapped32/generated/wrappedlibxfixestypes32.h
@@ -11,7 +11,9 @@
 #define ADDED_FUNCTIONS() 
 #endif
 
+typedef int32_t (*iFXpp_t)(void*, void*, void*);
 
-#define SUPER() ADDED_FUNCTIONS()
+#define SUPER() ADDED_FUNCTIONS() \
+	GO(XFixesQueryExtension, iFXpp_t)
 
 #endif // __wrappedlibxfixesTYPES32_H_
diff --git a/src/wrapped32/generated/wrappedlibxrandrtypes32.h b/src/wrapped32/generated/wrappedlibxrandrtypes32.h
index 1f2eb12b..0de1eca3 100644
--- a/src/wrapped32/generated/wrappedlibxrandrtypes32.h
+++ b/src/wrapped32/generated/wrappedlibxrandrtypes32.h
@@ -13,6 +13,7 @@
 
 typedef void (*vFp_t)(void*);
 typedef void* (*pFXL_t)(void*, uintptr_t);
+typedef int32_t (*iFXpp_t)(void*, void*, void*);
 typedef void* (*pFXLL_t)(void*, uintptr_t, uintptr_t);
 typedef void* (*pFXLp_t)(void*, uintptr_t, void*);
 typedef void* (*pFXpL_t)(void*, void*, uintptr_t);
@@ -25,6 +26,7 @@ typedef int32_t (*iFXpLLiiLWpi_t)(void*, void*, uintptr_t, uintptr_t, int32_t, i
 	GO(XRRGetProviderResources, pFXL_t) \
 	GO(XRRGetScreenResources, pFXL_t) \
 	GO(XRRGetScreenResourcesCurrent, pFXL_t) \
+	GO(XRRQueryExtension, iFXpp_t) \
 	GO(XRRQueryOutputProperty, pFXLL_t) \
 	GO(XRRListOutputProperties, pFXLp_t) \
 	GO(XRRGetCrtcInfo, pFXpL_t) \
diff --git a/src/wrapped32/generated/wrapper32.c b/src/wrapped32/generated/wrapper32.c
index 6e4230ff..397d198b 100644
--- a/src/wrapped32/generated/wrapper32.c
+++ b/src/wrapped32/generated/wrapper32.c
@@ -811,6 +811,7 @@ typedef int32_t (*iFESpV_t)(x64emu_t*, void*, void*, void*);
 typedef int32_t (*iFEXip_t)(x64emu_t*, void*, int32_t, void*);
 typedef int32_t (*iFEXlp_t)(x64emu_t*, void*, intptr_t, void*);
 typedef int32_t (*iFEXLp_t)(x64emu_t*, void*, uintptr_t, void*);
+typedef int32_t (*iFEXpp_t)(x64emu_t*, void*, void*, void*);
 typedef int32_t (*iFiiii_t)(int32_t, int32_t, int32_t, int32_t);
 typedef int32_t (*iFiiiu_t)(int32_t, int32_t, int32_t, uint32_t);
 typedef int32_t (*iFiiip_t)(int32_t, int32_t, int32_t, void*);
@@ -2307,6 +2308,7 @@ void iFESpV_32(x64emu_t *emu, uintptr_t fcn) { iFESpV_t fn = (iFESpV_t)fcn; R_EA
 void iFEXip_32(x64emu_t *emu, uintptr_t fcn) { iFEXip_t fn = (iFEXip_t)fcn; R_EAX = fn(emu, getDisplay(from_ptriv(R_ESP + 4)), from_ptri(int32_t, R_ESP + 8), from_ptriv(R_ESP + 12)); }
 void iFEXlp_32(x64emu_t *emu, uintptr_t fcn) { iFEXlp_t fn = (iFEXlp_t)fcn; R_EAX = fn(emu, getDisplay(from_ptriv(R_ESP + 4)), from_long(from_ptri(long_t, R_ESP + 8)), from_ptriv(R_ESP + 12)); }
 void iFEXLp_32(x64emu_t *emu, uintptr_t fcn) { iFEXLp_t fn = (iFEXLp_t)fcn; R_EAX = fn(emu, getDisplay(from_ptriv(R_ESP + 4)), from_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptriv(R_ESP + 12)); }
+void iFEXpp_32(x64emu_t *emu, uintptr_t fcn) { iFEXpp_t fn = (iFEXpp_t)fcn; R_EAX = fn(emu, getDisplay(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12)); }
 void iFiiii_32(x64emu_t *emu, uintptr_t fcn) { iFiiii_t fn = (iFiiii_t)fcn; R_EAX = fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16)); }
 void iFiiiu_32(x64emu_t *emu, uintptr_t fcn) { iFiiiu_t fn = (iFiiiu_t)fcn; R_EAX = fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptri(uint32_t, R_ESP + 16)); }
 void iFiiip_32(x64emu_t *emu, uintptr_t fcn) { iFiiip_t fn = (iFiiip_t)fcn; R_EAX = fn(from_ptri(int32_t, R_ESP + 4), from_ptri(int32_t, R_ESP + 8), from_ptri(int32_t, R_ESP + 12), from_ptriv(R_ESP + 16)); }
diff --git a/src/wrapped32/generated/wrapper32.h b/src/wrapped32/generated/wrapper32.h
index c9194cf6..5e57b8a7 100644
--- a/src/wrapped32/generated/wrapper32.h
+++ b/src/wrapped32/generated/wrapper32.h
@@ -762,6 +762,7 @@ void iFESpV_32(x64emu_t *emu, uintptr_t fnc);
 void iFEXip_32(x64emu_t *emu, uintptr_t fnc);
 void iFEXlp_32(x64emu_t *emu, uintptr_t fnc);
 void iFEXLp_32(x64emu_t *emu, uintptr_t fnc);
+void iFEXpp_32(x64emu_t *emu, uintptr_t fnc);
 void iFiiii_32(x64emu_t *emu, uintptr_t fnc);
 void iFiiiu_32(x64emu_t *emu, uintptr_t fnc);
 void iFiiip_32(x64emu_t *emu, uintptr_t fnc);
diff --git a/src/wrapped32/wrappedlibx11.c b/src/wrapped32/wrappedlibx11.c
index 15cf9e25..cfd99314 100644
--- a/src/wrapped32/wrappedlibx11.c
+++ b/src/wrapped32/wrappedlibx11.c
@@ -46,6 +46,7 @@ typedef int  (*iFp_t)(void*);
 typedef uint32_t (*uFv_t)(void);
 typedef int  (*iFpp_t)(void*, void*);
 typedef int32_t (*iFpl_t)(void*, intptr_t);
+typedef int  (*iFppp_t)(void*, void*, void*);
 typedef uintptr_t (*LFpii_t)(void*, int32_t, int32_t);
 typedef int32_t (*iFpiiL_t)(void*, int32_t, int32_t, uintptr_t);
 typedef void* (*pFpiiuu_t)(void*, int32_t, int32_t, uint32_t, uint32_t);
@@ -88,6 +89,16 @@ static int my32_wire_to_event_##A(void* dpy, void* re, void* event)
 }
 SUPER()
 #undef GO
+#define GO(A)   \
+static iFppp_t my32_rev_wire_to_event_fct_##A = NULL;                                               \
+static int my32_rev_wire_to_event_##A(void* dpy, void* re, void* event)                             \
+{                                                                                                   \
+    static my_XEvent_t re_l = {0};                                                                  \
+    int ret = my32_rev_wire_to_event_fct_##A (getDisplay(dpy), &re_l, event);                       \
+    convertXEvent(re, &re_l);                                                                       \
+}
+SUPER()
+#undef GO
 static void* findwire_to_eventFct(void* fct)
 {
     if(!fct) return fct;
@@ -103,13 +114,26 @@ static void* findwire_to_eventFct(void* fct)
 }
 static void* reverse_wire_to_eventFct(library_t* lib, void* fct)
 {
+    //Callsed from x86 world -> native world
     if(!fct) return fct;
-    if(CheckBridged(lib->w.bridge, fct))
-        return (void*)CheckBridged(lib->w.bridge, fct);
+    // first check if it's a wrapped function, that could be easy
     #define GO(A) if(my32_wire_to_event_##A == fct) return (void*)my32_wire_to_event_fct_##A;
     SUPER()
     #undef GO
-    return (void*)AddBridge(lib->w.bridge, iFppp_32, fct, 0, NULL);
+    if(FindElfAddress(my_context, (uintptr_t)fct))
+        return fct;
+    // it's a naitve one... so bridge it, but need transform XImage32 to XImage
+    void* f = NULL;
+    #define GO(A) if(!f && my32_rev_wire_to_event_fct_##A == fct) f = (void*)my32_rev_wire_to_event_##A;
+    SUPER()
+    #undef GO
+    #define GO(A) if(!f && !my32_rev_wire_to_event_fct_##A) {my32_rev_wire_to_event_fct_##A = fct; f = my32_rev_wire_to_event_##A;}
+    SUPER()
+    #undef GO
+    if(f)
+        return (void*)AddCheckBridge(lib->w.bridge, iFppp_32, f, 0, "X11_wire_to_event");
+    printf_log(LOG_NONE, "Warning, no more slot for reverse 32bits libX11 wire_to_event callback\n");
+    return fct;
 }
 
 // event_to_wire
@@ -123,6 +147,16 @@ static int my32_event_to_wire_##A(void* dpy, void* re, void* event)
 }
 SUPER()
 #undef GO
+#define GO(A)   \
+static iFppp_t my32_rev_event_to_wire_fct_##A = NULL;                                               \
+static int my32_rev_event_to_wire_##A(void* dpy, void* re, void* event)                             \
+{                                                                                                   \
+    static my_XEvent_t re_l = {0};                                                                  \
+    unconvertXEvent(&re_l, re);                                                                     \
+    return my32_rev_event_to_wire_fct_##A (getDisplay(dpy), &re_l, event);                          \
+}
+SUPER()
+#undef GO
 static void* findevent_to_wireFct(void* fct)
 {
     if(!fct) return fct;
@@ -138,13 +172,26 @@ static void* findevent_to_wireFct(void* fct)
 }
 static void* reverse_event_to_wireFct(library_t* lib, void* fct)
 {
+    //Callsed from x86 world -> native world
     if(!fct) return fct;
-    if(CheckBridged(lib->w.bridge, fct))
-        return (void*)CheckBridged(lib->w.bridge, fct);
+    // first check if it's a wrapped function, that could be easy
     #define GO(A) if(my32_event_to_wire_##A == fct) return (void*)my32_event_to_wire_fct_##A;
     SUPER()
     #undef GO
-    return (void*)AddBridge(lib->w.bridge, iFppp_32, fct, 0, NULL);
+    if(FindElfAddress(my_context, (uintptr_t)fct))
+        return fct;
+    // it's a naitve one... so bridge it, but need transform XImage32 to XImage
+    void* f = NULL;
+    #define GO(A) if(!f && my32_rev_event_to_wire_fct_##A == fct) f = (void*)my32_rev_event_to_wire_##A;
+    SUPER()
+    #undef GO
+    #define GO(A) if(!f && !my32_rev_event_to_wire_fct_##A) {my32_rev_event_to_wire_fct_##A = fct; f = my32_rev_event_to_wire_##A;}
+    SUPER()
+    #undef GO
+    if(f)
+        return (void*)AddCheckBridge(lib->w.bridge, iFppp_32, f, 0, "X11_event_to_wire");
+    printf_log(LOG_NONE, "Warning, no more slot for reverse 32bits libX11 event_to_wire callback\n");
+    return fct;
 }
 // error_handler
 #define GO(A)   \
@@ -383,12 +430,14 @@ static void* findXConnectionWatchProcFct(void* fct)
 #endif
 // xifevent
 #define GO(A)   \
-static uintptr_t my32_xifevent_fct_##A = 0;                                         \
-static int my32_xifevent_##A(void* dpy, my_XEvent_t* event, void* d)                \
-{                                                                                   \
-    static my_XEvent_32_t evt = {0};                                                \
-    convertXEvent(&evt, event);                                                     \
-    return RunFunctionFmt(my32_xifevent_fct_##A, "ppp", getDisplay(dpy), &evt, d);  \
+static uintptr_t my32_xifevent_fct_##A = 0;                                             \
+static int my32_xifevent_##A(void* dpy, my_XEvent_t* event, void* d)                    \
+{                                                                                       \
+    static my_XEvent_32_t evt[16] = {0};                                                \
+    static int idx = 0;                                                                 \
+    idx=(idx+1)&15;                                                                     \
+    convertXEvent(evt+idx, event);                                                      \
+    return RunFunctionFmt(my32_xifevent_fct_##A, "ppp", getDisplay(dpy), evt+idx, d);   \
 }
 SUPER()
 #undef GO
diff --git a/src/wrapped32/wrappedlibxext.c b/src/wrapped32/wrappedlibxext.c
index 31d7092b..daadc460 100644
--- a/src/wrapped32/wrappedlibxext.c
+++ b/src/wrapped32/wrappedlibxext.c
@@ -11,11 +11,12 @@
 #include "bridge.h"
 #include "librarian/library_private.h"
 #include "x64emu.h"
-#include "emu/x64emu_private.h"
 #include "callback.h"
 #include "librarian.h"
 #include "box32context.h"
 #include "emu/x64emu_private.h"
+#include "myalign32.h"
+#include "elfloader.h"
 #include "converter32.h"
 
 #ifdef ANDROID
@@ -32,6 +33,8 @@ typedef struct _XImage XImage;
 void BridgeImageFunc(x64emu_t *emu, XImage *img);
 void UnbridgeImageFunc(x64emu_t *emu, XImage *img);
 typedef int (*XextErrorHandler)(void *, void *, void*);
+typedef int  (*iFpp_t)(void*, void*);
+typedef int  (*iFppp_t)(void*, void*, void*);
 
 #include "generated/wrappedlibxexttypes32.h"
 
@@ -236,14 +239,25 @@ static void* find_close_display_Fct(void* fct)
     printf_log(LOG_NONE, "Warning, no more slot for libXext close_display callback\n");
     return NULL;
 }
-// wire_to_event ...
+// wire_to_event
 #define GO(A)   \
-static uintptr_t my_wire_to_event_fct_##A = 0;                                          \
-static int my_wire_to_event_##A(void* a, void* b, void* c)                              \
-{                                                                                       \
-    static my_XEvent_32_t evt;                                                          \
-    int ret = RunFunctionFmt(my_wire_to_event_fct_##A, "ppp", getDisplay(a), &evt, c);  \
-    unconvertXEvent(b, &evt);                                                           \
+static uintptr_t my32_wire_to_event_fct_##A = 0;                                                    \
+static int my32_wire_to_event_##A(void* dpy, void* re, void* event)                                 \
+{                                                                                                   \
+    static my_XEvent_32_t re_s = {0};                                                               \
+    int ret = (int)RunFunctionFmt(my32_wire_to_event_fct_##A, "ppp", getDisplay(dpy), &re_s, event);\
+    unconvertXEvent(re, &re_s);                                                                     \
+    return ret;                                                                                     \
+}
+SUPER()
+#undef GO
+#define GO(A)   \
+static iFppp_t my32_rev_wire_to_event_fct_##A = NULL;                                               \
+static int my32_rev_wire_to_event_##A(void* dpy, void* re, void* event)                             \
+{                                                                                                   \
+    static my_XEvent_t re_l = {0};                                                                  \
+    int ret = my32_rev_wire_to_event_fct_##A (getDisplay(dpy), &re_l, event);                       \
+    convertXEvent(re, &re_l);                                                                       \
 }
 SUPER()
 #undef GO
@@ -251,23 +265,57 @@ static void* find_wire_to_event_Fct(void* fct)
 {
     if(!fct) return fct;
     if(GetNativeFnc((uintptr_t)fct))  return GetNativeFnc((uintptr_t)fct);
-    #define GO(A) if(my_wire_to_event_fct_##A == (uintptr_t)fct) return my_wire_to_event_##A;
+    #define GO(A) if(my32_wire_to_event_fct_##A == (uintptr_t)fct) return my32_wire_to_event_##A;
     SUPER()
     #undef GO
-    #define GO(A) if(my_wire_to_event_fct_##A == 0) {my_wire_to_event_fct_##A = (uintptr_t)fct; return my_wire_to_event_##A; }
+    #define GO(A) if(my32_wire_to_event_fct_##A == 0) {my32_wire_to_event_fct_##A = (uintptr_t)fct; return my32_wire_to_event_##A; }
     SUPER()
     #undef GO
-    printf_log(LOG_NONE, "Warning, no more slot for libXext wire_to_event callback\n");
+    printf_log(LOG_NONE, "Warning, no more slot for libX11 wire_to_event callback\n");
     return NULL;
 }
-// event_to_wire ...
+static void* reverse_wire_to_event_Fct(library_t* lib, void* fct)
+{
+    //Callsed from x86 world -> native world
+    if(!fct) return fct;
+    // first check if it's a wrapped function, that could be easy
+    #define GO(A) if(my32_wire_to_event_##A == fct) return (void*)my32_wire_to_event_fct_##A;
+    SUPER()
+    #undef GO
+    if(FindElfAddress(my_context, (uintptr_t)fct))
+        return fct;
+    // it's a naitve one... so bridge it, but need transform XImage32 to XImage
+    void* f = NULL;
+    #define GO(A) if(!f && my32_rev_wire_to_event_fct_##A == fct) f = (void*)my32_rev_wire_to_event_##A;
+    SUPER()
+    #undef GO
+    #define GO(A) if(!f && !my32_rev_wire_to_event_fct_##A) {my32_rev_wire_to_event_fct_##A = fct; f = my32_rev_wire_to_event_##A;}
+    SUPER()
+    #undef GO
+    if(f)
+        return (void*)AddCheckBridge(lib->w.bridge, iFppp_32, f, 0, "X11_wire_to_event");
+    printf_log(LOG_NONE, "Warning, no more slot for reverse 32bits libX11 wire_to_event callback\n");
+    return fct;
+}
+
+// event_to_wire
 #define GO(A)   \
-static uintptr_t my_event_to_wire_fct_##A = 0;                                      \
-static int my_event_to_wire_##A(void* a, void* b, void* c)                          \
-{                                                                                   \
-    static my_XEvent_32_t evt;                                                      \
-    convertXEvent(&evt, b);                                                         \
-    return RunFunctionFmt(my_event_to_wire_fct_##A, "ppp", getDisplay(a), &evt, c); \
+static uintptr_t my32_event_to_wire_fct_##A = 0;                                                    \
+static int my32_event_to_wire_##A(void* dpy, void* re, void* event)                                 \
+{                                                                                                   \
+    my_XEvent_32_t re_s = {0};                                                                      \
+    convertXEvent(&re_s, re);                                                                       \
+    return (int)RunFunctionFmt(my32_event_to_wire_fct_##A, "ppp", getDisplay(dpy), &re_s, event);   \
+}
+SUPER()
+#undef GO
+#define GO(A)   \
+static iFppp_t my32_rev_event_to_wire_fct_##A = NULL;                                               \
+static int my32_rev_event_to_wire_##A(void* dpy, void* re, void* event)                             \
+{                                                                                                   \
+    static my_XEvent_t re_l = {0};                                                                  \
+    unconvertXEvent(&re_l, re);                                                                     \
+    return my32_rev_event_to_wire_fct_##A (getDisplay(dpy), &re_l, event);                          \
 }
 SUPER()
 #undef GO
@@ -275,15 +323,38 @@ static void* find_event_to_wire_Fct(void* fct)
 {
     if(!fct) return fct;
     if(GetNativeFnc((uintptr_t)fct))  return GetNativeFnc((uintptr_t)fct);
-    #define GO(A) if(my_event_to_wire_fct_##A == (uintptr_t)fct) return my_event_to_wire_##A;
+    #define GO(A) if(my32_event_to_wire_fct_##A == (uintptr_t)fct) return my32_event_to_wire_##A;
     SUPER()
     #undef GO
-    #define GO(A) if(my_event_to_wire_fct_##A == 0) {my_event_to_wire_fct_##A = (uintptr_t)fct; return my_event_to_wire_##A; }
+    #define GO(A) if(my32_event_to_wire_fct_##A == 0) {my32_event_to_wire_fct_##A = (uintptr_t)fct; return my32_event_to_wire_##A; }
     SUPER()
     #undef GO
-    printf_log(LOG_NONE, "Warning, no more slot for libXext event_to_wire callback\n");
+    printf_log(LOG_NONE, "Warning, no more slot for libX11 event_to_wire callback\n");
     return NULL;
 }
+static void* reverse_event_to_wire_Fct(library_t* lib, void* fct)
+{
+    //Callsed from x86 world -> native world
+    if(!fct) return fct;
+    // first check if it's a wrapped function, that could be easy
+    #define GO(A) if(my32_event_to_wire_##A == fct) return (void*)my32_event_to_wire_fct_##A;
+    SUPER()
+    #undef GO
+    if(FindElfAddress(my_context, (uintptr_t)fct))
+        return fct;
+    // it's a naitve one... so bridge it, but need transform XImage32 to XImage
+    void* f = NULL;
+    #define GO(A) if(!f && my32_rev_event_to_wire_fct_##A == fct) f = (void*)my32_rev_event_to_wire_##A;
+    SUPER()
+    #undef GO
+    #define GO(A) if(!f && !my32_rev_event_to_wire_fct_##A) {my32_rev_event_to_wire_fct_##A = fct; f = my32_rev_event_to_wire_##A;}
+    SUPER()
+    #undef GO
+    if(f)
+        return (void*)AddCheckBridge(lib->w.bridge, iFppp_32, f, 0, "Xext_event_to_wire");
+    printf_log(LOG_NONE, "Warning, no more slot for reverse 32bits libXext event_to_wire callback\n");
+    return fct;
+}
 // error ...
 #define GO(A)   \
 static uintptr_t my_error_fct_##A = 0;                                          \
diff --git a/src/wrapped32/wrappedlibxfixes.c b/src/wrapped32/wrappedlibxfixes.c
index 16352a7c..cc0f3a22 100644
--- a/src/wrapped32/wrappedlibxfixes.c
+++ b/src/wrapped32/wrappedlibxfixes.c
@@ -6,10 +6,17 @@
 
 #include "wrappedlibs.h"
 
+#include "debug.h"
 #include "wrapper32.h"
 #include "bridge.h"
 #include "librarian/library_private.h"
 #include "x64emu.h"
+#include "emu/x64emu_private.h"
+#include "callback.h"
+#include "librarian.h"
+#include "box32context.h"
+#include "emu/x64emu_private.h"
+#include "converter32.h"
 
 #ifdef ANDROID
     static const char* libxfixesName = "libXfixes.so";
@@ -19,6 +26,21 @@
 
 #define LIBNAME libxfixes
 
+#include "libtools/my_x11_conv.h"
+
+#include "generated/wrappedlibxfixestypes32.h"
+
+#include "wrappercallback32.h"
+
+EXPORT int my32_XFixesQueryExtension(x64emu_t* emu, void* dpy, int* event_base, int* error_base)
+{
+    int ret = my->XFixesQueryExtension(dpy, event_base, error_base);
+    if(!ret) return ret;
+
+    register_XFixes_events(*event_base);
+    return ret;
+}
+
 #if 0
 #ifdef ANDROID
 #define NEEDED_LIBS "libX11.so", "libxcb.so", "libXau.so", "libXdmcp.so"
@@ -27,4 +49,7 @@
 #endif
 #endif
 
+#define CUSTOM_FINI \
+    unregister_XFixes_events();
+
 #include "wrappedlib_init32.h"
diff --git a/src/wrapped32/wrappedlibxfixes_private.h b/src/wrapped32/wrappedlibxfixes_private.h
index 9fb4ffb6..01ca0512 100644
--- a/src/wrapped32/wrappedlibxfixes_private.h
+++ b/src/wrapped32/wrappedlibxfixes_private.h
@@ -25,7 +25,7 @@ GO(XFixesGetCursorName, pFXLbL_)
 GO(XFixesHideCursor, vFXL)
 GO(XFixesIntersectRegion, vFXLLL)
 GO(XFixesInvertRegion, vFXLpL)
-GO(XFixesQueryExtension, iFXpp)
+GOM(XFixesQueryExtension, iFEXpp)
 GO(XFixesQueryVersion, iFXpp)
 GO(XFixesRegionExtents, vFXLL)
 GO(XFixesSelectCursorInput, vFXLL)
diff --git a/src/wrapped32/wrappedlibxi.c b/src/wrapped32/wrappedlibxi.c
index 16bfab07..570e2240 100644
--- a/src/wrapped32/wrappedlibxi.c
+++ b/src/wrapped32/wrappedlibxi.c
@@ -32,58 +32,12 @@
 #define NEEDED_LIBS "libX11.so.6", "libXext.so.6"
 #endif
 
-#include "libtools/my_x11_defs.h"
-#include "libtools/my_x11_defs_32.h"
+#include "libtools/my_x11_conv.h"
 
 #include "generated/wrappedlibxitypes32.h"
 
 #include "wrappercallback32.h"
 
-void inplace_XIDeviceInfo_shrink(void* a, int n)
-{
-    if(!a || !n) return;
-    my_XIDeviceInfo_32_t* dst = a;
-    my_XIDeviceInfo_t* src = a;
-
-    for(int i=0; i<n; ++i, ++src, ++dst) {
-        dst->deviceid = src->deviceid;
-        dst->name = to_ptrv(src->name);
-        dst->use = src->use;
-        dst->attachment = src->attachment;
-        dst->enabled = src->enabled;
-        for(int j=0; j<src->num_classes; ++j)
-            ((ptr_t*)src->classes)[j] = to_ptrv(src->classes[j]);
-        dst->num_classes = src->num_classes;
-        dst->classes = to_ptrv(src->classes);
-    }
-    // mark last record, even on only 1 record, thos last 2 uint32_t are free
-    dst->deviceid = 0;
-    dst->name = 0;
-}
-
-int inplace_XIDeviceInfo_enlarge(void* a)
-{
-    if(!a) return 0;
-    my_XIDeviceInfo_t* dst = a;
-    my_XIDeviceInfo_32_t* src = a;
-    int n = 0;
-    while(src[n].deviceid && src[n].name) ++n;
-    src+=n-1;
-    dst+=n-1;
-    for(int i=n-1; i>=0; --i, --src, --dst) {
-        dst->classes = from_ptrv(src->classes);
-        dst->num_classes = src->num_classes;
-        dst->enabled = src->enabled;
-        dst->attachment = src->attachment;
-        dst->use = src->use;
-        dst->name = from_ptrv(src->name);
-        dst->deviceid = src->deviceid;
-        for(int j=dst->num_classes-1; j>=0; --j)
-            dst->classes[j] = from_ptrv(((ptr_t*)dst->classes)[j]);
-    }
-    return n;
-}
-
 EXPORT void* my32_XIQueryDevice(x64emu_t* emu, void* dpy, int deviceid, int* ndevices)
 {
     void* ret = my->XIQueryDevice(dpy, deviceid, ndevices);
@@ -123,30 +77,10 @@ EXPORT void* my32_XIGetSelectedEvents(x64emu_t* emu, void* dpy, XID window, int*
     return ret;
 }
 
-void inplace_XDevice_shrink(void* a)
-{
-    if(!a) return;
-    my_XDevice_t* src = a;
-    my_XDevice_32_t* dst = a;
-
-    dst->device_id = src->device_id;
-    dst->num_classes = src->num_classes;
-    dst->classes = to_ptrv(src->classes);
-}
-void inplace_XDevice_enlarge(void* a)
-{
-    if(!a) return;
-    my_XDevice_32_t* src = a;
-    my_XDevice_t* dst = a;
-
-    dst->classes = from_ptrv(src->classes);
-    dst->num_classes = src->num_classes;
-    dst->device_id = src->device_id;
-}
-
 EXPORT void* my32_XOpenDevice(x64emu_t* emu, void* dpy, XID id)
 {
     void* ret = my->XOpenDevice(dpy, id);
+    register_XDevice_events(ret);
     inplace_XDevice_shrink(ret);
     return ret;
 }
@@ -154,6 +88,7 @@ EXPORT void* my32_XOpenDevice(x64emu_t* emu, void* dpy, XID id)
 EXPORT int my32_XCloseDevice(x64emu_t* emu, void* dpy, void* d)
 {
     inplace_XDevice_enlarge(d);
+    unregister_XDevice_events(d);
     return my->XCloseDevice(dpy, d);
 }
 
@@ -164,5 +99,4 @@ EXPORT int my32_XGetDeviceButtonMapping(x64emu_t* emu, void* dpy, void* d, void*
     inplace_XDevice_shrink(d);
 }
 
-
 #include "wrappedlib_init32.h"
diff --git a/src/wrapped32/wrappedlibxrandr.c b/src/wrapped32/wrappedlibxrandr.c
index db80bd9c..802d22f3 100644
--- a/src/wrapped32/wrappedlibxrandr.c
+++ b/src/wrapped32/wrappedlibxrandr.c
@@ -151,10 +151,21 @@ EXPORT void* my32_XRRQueryOutputProperty(x64emu_t* emu, void* dpy, XID output, X
     return inplace_XRRPropertyInfo_shrink(ret);
 }
 
+EXPORT int my32_XRRQueryExtension(x64emu_t* emu, void* dpy, int* event_base, int* error_base)
+{
+    int ret = my->XRRQueryExtension(dpy, event_base, error_base);
+    if(!ret) return ret;
+    register_XRandR_events(*event_base);
+    return ret;
+}
+
 #ifdef ANDROID
 #define NEEDED_LIBS "libX11.so", "libXext.so", "libXrender.so"
 #else
 #define NEEDED_LIBS "libX11.so.6", "libXext.so.6", "libXrender.so.1"
 #endif
 
+#define CUSTOM_FINI \
+    unregister_XRandR_events();
+
 #include "wrappedlib_init32.h"
diff --git a/src/wrapped32/wrappedlibxrandr_private.h b/src/wrapped32/wrappedlibxrandr_private.h
index bfed161b..a2b9fe89 100644
--- a/src/wrapped32/wrappedlibxrandr_private.h
+++ b/src/wrapped32/wrappedlibxrandr_private.h
@@ -6,7 +6,7 @@ GO(XRRQueryVersion, iFXpp)
 GO(XRRFreeScreenConfigInfo, vFp)
 GOM(XRRGetCrtcInfo, pFEXpL)
 GOM(XRRListOutputProperties, pFEXLp)
-GO(XRRQueryExtension, iFXpp)
+GOM(XRRQueryExtension, iFEXpp)
 //GO(XRRAllocModeInfo, bLuuLuuuuuuupuL_Fpi)
 //GO(XRRGetProviderProperty, iFXLLlliiLbL_pbL_bL_bp_)
 //GO(XRRListProviderProperties, bL_FXLp)