[BOX32] Refactored X11 wrapping, and add a few more functions

14 files changed, 1346 insertions, 904 deletions

diff --git a/src/include/box64context.h b/src/include/box64context.h
index 532c1aaf..8899460e 100644
--- a/src/include/box64context.h
+++ b/src/include/box64context.h
@@ -184,6 +184,7 @@ typedef struct box64context_s {
     library_t           *sdl1mixerlib;
     library_t           *sdl2lib;
     library_t           *sdl2mixerlib;
+    library_t           *libx11;
     linkmap_t           *linkmap;
     linkmap32_t         *linkmap32;
     void*               sdl1allocrw;    // SDL1 AllocRW/FreeRW function
diff --git a/src/libtools/my_x11_conv.c b/src/libtools/my_x11_conv.c
new file mode 100644
index 00000000..7a7c1259
--- /dev/null
+++ b/src/libtools/my_x11_conv.c
@@ -0,0 +1,967 @@
+#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"
+
+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);
+    }
+}
+
+#define N_DISPLAY 4
+#define N_SCREENS 16
+my_XDisplay_t* my32_Displays_64[N_DISPLAY] = {0};
+struct my_XFreeFuncs_32 my32_free_funcs_32[N_DISPLAY] = {0};
+struct my_XLockPtrs_32 my32_lock_fns_32[N_DISPLAY] = {0};
+my_Screen_32_t my32_screens[N_DISPLAY*N_SCREENS] = {0};
+int n_screeens = 0;
+my_XDisplay_32_t my32_Displays_32[N_DISPLAY] = {0};
+
+void* getDisplay(void* d)
+{
+    if(!d) return d;
+    for(int i=0; i<N_DISPLAY; ++i)
+        if(((&my32_Displays_32[i])==d) || (my32_Displays_64[i]==d)) {
+            return my32_Displays_64[i];
+        }
+        printf_log(LOG_INFO, "BOX32: Warning, 32bits Display %p not found\n", d);
+    return d;
+}
+
+void* FindDisplay(void* d)
+{
+    if(!d) return d;
+    for(int i=0; i<N_DISPLAY; ++i)
+        if((my32_Displays_64[i]==d) || ((&my32_Displays_32[i])==d)) {
+            return &my32_Displays_32[i];
+        }
+    return d;
+}
+
+void convert_Screen_to_32(void* d, void* s)
+{
+    my_Screen_t* src = s;
+    my_Screen_32_t* dst = d;
+    dst->ext_data = to_ptrv(src->ext_data);
+    dst->display = to_ptrv(FindDisplay(src->display));
+    dst->root = to_ulong(src->root);
+    dst->width = src->width;
+    dst->mwidth = src->mwidth;
+    dst->ndepths = src->ndepths;
+    dst->depths = to_ptrv(src->depths);
+    dst->root_depth = src->root_depth;
+    dst->root_visual = to_ptrv(src->root_visual);
+    dst->default_gc = to_ptrv(src->default_gc);
+    dst->cmap = to_ulong(src->cmap);
+    dst->white_pixel = to_ulong(src->white_pixel);
+    dst->black_pixel = to_ulong(src->black_pixel);
+    dst->max_maps = src->max_maps;
+    dst->backing_store = src->backing_store;
+    dst->save_unders = src->save_unders;
+    dst->root_input_mask = to_long(src->root_input_mask);
+}
+
+void* my_dlopen(x64emu_t* emu, void *filename, int flag);
+void* addDisplay(void* d)
+{
+    if(!my_context->libx11) {
+        // the lib has not be loaded directly... need to open it! leaking the lib handle...
+        #ifdef ANDROID
+        my_dlopen(thread_get_emu(), "libX11.so", RTLD_NOW);
+        #else
+        my_dlopen(thread_get_emu(), "libX11.so.6", RTLD_NOW);
+        #endif
+    }
+    my_XDisplay_t* dpy = (my_XDisplay_t*)d;
+    // look for a free slot, or a display already there
+    my_XDisplay_32_t* ret = NULL;
+    struct my_XFreeFuncs_32 *free_funcs = NULL;
+    struct my_XLockPtrs_32 *lock_fns = NULL;
+    for(int i=0; i<N_DISPLAY && !ret; ++i)
+        if(my32_Displays_64[i]==dpy)
+            return &my32_Displays_32[i];
+    for(int i=0; i<N_DISPLAY && !ret; ++i) {
+        if(!my32_Displays_64[i]) {
+            my32_Displays_64[i] = dpy;
+            ret = &my32_Displays_32[i];
+            free_funcs = &my32_free_funcs_32[i];
+            ret->free_funcs = to_ptrv(free_funcs);
+            lock_fns = &my32_lock_fns_32[i];
+            ret->lock_fns = to_ptrv(lock_fns);
+        }
+    }
+    if(!ret) {
+        printf_log(LOG_INFO, "BOX32: No more slot available for libX11 Display!");
+        return d;
+    }
+
+    bridge_t* system = my_context->libx11->w.bridge;
+
+    // partial copy...
+
+    #define GO(A, W)\
+    if(dpy->A)      \
+        if(!CheckBridged(system, dpy->A)) \
+            ret->A = AddCheckBridge(system, W, dpy->A, 0, #A); \
+
+    #define GO2(A, B, W) \
+    if(dpy->A && dpy->A->B)  \
+        if(!CheckBridged(system, dpy->A->B)) \
+            A->B = AddCheckBridge(system, W, dpy->A->B, 0, #B "_" #A); \
+
+    ret->vendor = to_cstring(dpy->vendor);
+    ret->fd = dpy->fd;
+    ret->conn_checker = dpy->conn_checker;
+    ret->proto_major_version = dpy->proto_major_version;
+    ret->proto_minor_version = dpy->proto_minor_version;
+    ret->xdefaults = to_cstring(dpy->xdefaults);
+    ret->display_name = to_cstring(dpy->display_name);
+    ret->default_screen = dpy->default_screen;
+    ret->nscreens = dpy->nscreens;
+    if(dpy->screens) {
+        ret->screens = to_ptrv(&my32_screens[n_screeens]);
+        for(int i=0; i<dpy->nscreens; ++i) {
+            if(n_screeens==N_DISPLAY*N_SCREENS) {
+                printf_log(LOG_INFO, "BOX32: Warning, no more libX11 Screen slots!");
+                break;
+            }
+            convert_Screen_to_32(&my32_screens[n_screeens++], &dpy->screens[i]);
+        }
+    } else
+        ret->screens = 0;
+
+    GO2(free_funcs, atoms, vFp_32)
+    GO2(free_funcs, modifiermap, iFp_32)
+    GO2(free_funcs, key_bindings, vFp_32)
+    GO2(free_funcs, context_db, vFp_32)
+    GO2(free_funcs, defaultCCCs, vFp_32)
+    GO2(free_funcs, clientCmaps, vFp_32)
+    GO2(free_funcs, intensityMaps, vFp_32)
+    GO2(free_funcs, im_filters, vFp_32)
+    GO2(free_funcs, xkb, vFp_32)
+    GO(resource_alloc, LFp_32)
+    GO(synchandler, iFp_32)
+    //TODO: ext_procs?
+    //TODO: event_vec?
+    //TODO: wire_vec?
+    //TODO: async_handlers?
+    GO2(lock_fns, lock_display, vFp_32)
+    GO2(lock_fns, unlock_display, vFp_32)
+    GO(idlist_alloc, vFppi_32)
+    //TODO: error_vec?
+    //TODO: flushes
+    //TODO: im_fd_info?
+    //TODO: conn_watchers
+    GO(savedsynchandler, iFp_32)
+    //TODO: generic_event_vec?
+    //TODO: generic_event_copy_vec?
+
+
+    #undef GO
+    #undef GO2
+
+    return ret;
+}
+
+void delDisplay(void* d)
+{
+    for(int i=0; i<N_DISPLAY; ++i) {
+        // crude free of ressources... not perfect
+        if(my32_Displays_64[i]==d) {
+            my32_Displays_64[i] = NULL;
+            return;
+        }
+    }
+}
+
+void convert_XWMints_to_64(void* d, void* s)
+{
+    my_XWMHints_t* dst = d;
+    my_XWMHints_32_t* src = s;
+    long flags = from_long(src->flags);
+    // reverse order
+    if(flags&XWMHint_WindowGroupHint)   dst->window_group = from_ulong(src->window_group);
+    if(flags&XWMHint_IconMaskHint)      dst->icon_mask = from_ulong(src->icon_mask);
+    if(flags&XWMHint_IconPositionHint)  {dst->icon_y = src->icon_y; dst->icon_x = src->icon_x;}
+    if(flags&XWMHint_IconWindowHint)    dst->icon_window = from_ulong(src->icon_window);
+    if(flags&XWMHint_IconPixmapHint)    dst->icon_pixmap = from_ulong(src->icon_pixmap);
+    if(flags&XWMHint_StateHint)         dst->initial_state = src->initial_state;
+    if(flags&XWMHint_InputHint)         dst->input = src->input;
+
+    dst->flags = flags;
+}
+void inplace_enlarge_wmhints(void* hints)
+{
+    if(!hints) return;
+    my_XWMHints_32_t* src = hints;
+    my_XWMHints_t* dst = hints;
+    long flags = from_long(src->flags);
+    // reverse order
+    if(flags&XWMHint_WindowGroupHint)   dst->window_group = from_ulong(src->window_group);
+    if(flags&XWMHint_IconMaskHint)      dst->icon_mask = from_ulong(src->icon_mask);
+    if(flags&XWMHint_IconPositionHint)  {dst->icon_y = src->icon_y; dst->icon_x = src->icon_x;}
+    if(flags&XWMHint_IconWindowHint)    dst->icon_window = from_ulong(src->icon_window);
+    if(flags&XWMHint_IconPixmapHint)    dst->icon_pixmap = from_ulong(src->icon_pixmap);
+    if(flags&XWMHint_StateHint)         dst->initial_state = src->initial_state;
+    if(flags&XWMHint_InputHint)         dst->input = src->input;
+
+    dst->flags = flags;
+}
+void inplace_shrink_wmhints(void* hints)
+{
+    if(!hints) return;
+    my_XWMHints_t* src = hints;
+    my_XWMHints_32_t* dst = hints;
+    long_t flags = to_long(src->flags);
+    // forward order
+    if(flags&XWMHint_InputHint)         dst->input = src->input;
+    if(flags&XWMHint_StateHint)         dst->initial_state = src->initial_state;
+    if(flags&XWMHint_IconPixmapHint)    dst->icon_pixmap = to_ulong(src->icon_pixmap);
+    if(flags&XWMHint_IconWindowHint)    dst->icon_window = to_ulong(src->icon_window);
+    if(flags&XWMHint_IconPositionHint)  {dst->icon_y = src->icon_y; dst->icon_x = src->icon_x;}
+    if(flags&XWMHint_IconMaskHint)      dst->icon_mask = to_ulong(src->icon_mask);
+    if(flags&XWMHint_WindowGroupHint)   dst->window_group = to_ulong(src->window_group);
+
+    dst->flags = flags;
+}
+
+void convert_XSizeHints_to_64(void* d, void *s)
+{
+    //XSizeHints is a long flag and 17*int...
+    long flags = to_long(*(long_t*)s);
+    memcpy(d+8, s+4, 17*4);
+    *(long*)d = flags;
+}
+void inplace_enlarge_wmsizehints(void* hints)
+{
+    //XSizeHints is a long flag and 17*int...
+    long flags = to_long(*(long_t*)hints);
+    memmove(hints+8, hints+4, 17*4);
+    *(long*)hints = flags;
+}
+void inplace_shrink_wmsizehints(void* hints)
+{
+    //XSizeHints is a long flag and 17*int...
+    long_t flags = from_long(*(long*)hints);
+    memmove(hints+4, hints+8, 17*4);
+    *(long_t*)hints = flags;
+}
+
+void convert_XWindowAttributes_to_32(void* d, void* s)
+{
+    my_XWindowAttributes_t* src = s;
+    my_XWindowAttributes_32_t* dst = d;
+    dst->x = src->x;
+    dst->y = src->y;
+    dst->width = src->width;
+    dst->height = src->height;
+    dst->border_width = src->border_width;
+    dst->depth = src->depth;
+    dst->visual = to_ptrv(src->visual);
+    dst->root = to_ulong(src->root);
+    dst->c_class = src->c_class;
+    dst->bit_gravity = src->bit_gravity;
+    dst->win_gravity = src->win_gravity;
+    dst->backing_store = src->backing_store;
+    dst->backing_planes = to_ulong(src->backing_planes);
+    dst->backing_pixel = to_ulong(src->backing_pixel);
+    dst->save_under = src->save_under;
+    dst->colormap = to_ulong(src->colormap);
+    dst->map_installed = src->map_installed;
+    dst->map_state = src->map_state;
+    dst->all_event_masks = to_long(src->all_event_masks);
+    dst->your_event_mask = to_long(src->your_event_mask);
+    dst->do_not_propagate_mask = to_long(src->do_not_propagate_mask);
+    dst->override_redirect = src->override_redirect;
+    dst->screen = to_ptrv(src->screen);
+}
+
+void inplace_XModifierKeymap_shrink(void* a)
+{
+    my_XModifierKeymap_32_t *d = a;
+    my_XModifierKeymap_t* s = a;
+
+    d->max_keypermod = s->max_keypermod;
+    d->modifiermap = to_ptrv(s->modifiermap);
+}
+void inplace_XModifierKeymap_enlarge(void* a)
+{
+    my_XModifierKeymap_t *d = a;
+    my_XModifierKeymap_32_t* s = a;
+
+    d->modifiermap = from_ptrv(s->modifiermap);
+    d->max_keypermod = s->max_keypermod;
+}
+
+void convert_XVisualInfo_to_32(my_XVisualInfo_32_t* dst, my_XVisualInfo_t* src)
+{
+    dst->visual = to_ptrv(src->visual);
+    dst->visualid = to_ulong(src->visualid);
+    dst->screen = src->screen;
+    dst->depth = src->depth;
+    dst->c_class = src->c_class;
+    dst->red_mask = to_ulong(src->red_mask);
+    dst->green_mask = to_ulong(src->green_mask);
+    dst->blue_mask = to_ulong(src->blue_mask);
+    dst->colormap_size = src->colormap_size;
+    dst->bits_per_rgb = src->bits_per_rgb;
+}
+void convert_XVisualInfo_to_64(my_XVisualInfo_t* dst, my_XVisualInfo_32_t* src)
+{
+    dst->bits_per_rgb = src->bits_per_rgb;
+    dst->colormap_size = src->colormap_size;
+    dst->blue_mask = from_ulong(src->blue_mask);
+    dst->green_mask = from_ulong(src->green_mask);
+    dst->red_mask = from_ulong(src->red_mask);
+    dst->c_class = src->c_class;
+    dst->depth = src->depth;
+    dst->screen = src->screen;
+    dst->visualid = from_ulong(src->visualid);
+    dst->visual = from_ptrv(src->visual);
+}
+void inplace_XVisualInfo_shrink(void *a)
+{
+    if(!a) return;
+    my_XVisualInfo_t *src = a;
+    my_XVisualInfo_32_t* dst = a;
+
+    convert_XVisualInfo_to_32(dst, src);
+}
+void inplace_XVisualInfo_enlarge(void *a)
+{
+    if(!a) return;
+    my_XVisualInfo_32_t *src = a;
+    my_XVisualInfo_t* dst = a;
+
+    convert_XVisualInfo_to_64(dst, src);
+}
+
+void inplace_XdbeVisualInfo_shrink(void* a)
+{
+    if(!a) return;
+    my_XdbeVisualInfo_t *src = a;
+    my_XdbeVisualInfo_32_t* dst = a;
+
+    dst->visual = to_ulong(src->visual);
+    dst->depth = src->depth;
+    dst->perflevel = src->perflevel;
+}
+void inplace_XdbeScreenVisualInfo_shrink(void* a)
+{
+    if(!a) return;
+    my_XdbeScreenVisualInfo_t *src = a;
+    my_XdbeScreenVisualInfo_32_t* dst = a;
+
+    for(int i=0; i<src->count; ++i)
+        inplace_XdbeVisualInfo_shrink(src->visinfo+i);
+    dst->count = src->count;
+    dst->visinfo = to_ptrv(src->visinfo);
+}
+void inplace_XdbeVisualInfo_enlarge(void* a)
+{
+    if(!a) return;
+    my_XdbeVisualInfo_32_t *src = a;
+    my_XdbeVisualInfo_t* dst = a;
+
+    dst->perflevel = src->perflevel;
+    dst->depth = src->depth;
+    dst->visual = from_ulong(src->visual);
+}
+void inplace_XdbeScreenVisualInfo_enlarge(void* a)
+{
+    if(!a) return;
+    my_XdbeScreenVisualInfo_32_t *src = a;
+    my_XdbeScreenVisualInfo_t* dst = a;
+
+    dst->visinfo = from_ptrv(src->visinfo);
+    dst->count = src->count;
+    for(int i=dst->count-1; i>=0; --i)
+        inplace_XdbeVisualInfo_enlarge(dst->visinfo+i);
+}
+
+void inplace_XExtDisplayInfo_shrink(void* a)
+{
+    if(!a) return;
+    my_XExtDisplayInfo_t* src = a;
+    my_XExtDisplayInfo_32_t* dst = a;
+
+    dst->next = to_ptrv(src->next);
+    dst->display = to_ptrv(getDisplay(src->display));
+    dst->codes = to_ptrv(src->codes);
+    dst->data = to_ptrv(src->data);
+}
+void inplace_XExtDisplayInfo_enlarge(void* a)
+{
+    if(!a) return;
+    my_XExtDisplayInfo_32_t* src = a;
+    my_XExtDisplayInfo_t* dst = a;
+
+    dst->data = from_ptrv(src->data);
+    dst->codes = from_ptrv(src->codes);
+    dst->display = FindDisplay(from_ptrv(src->display));
+    dst->next = from_ptrv(src->next);
+}
+
+void* inplace_XExtensionInfo_shrink(void* a)
+{
+    if(!a) return a;
+    my_XExtensionInfo_t* src = a;
+    my_XExtensionInfo_32_t* dst = a;
+
+    my_XExtDisplayInfo_t* head = src->head;
+    while(head) {
+        my_XExtDisplayInfo_t* next = head->next;
+        inplace_XExtDisplayInfo_shrink(head);
+        head = next;
+    }
+    dst->head = to_ptrv(src->head);
+    dst->cur = to_ptrv(src->cur);
+    dst->ndisplays = src->ndisplays;
+    return a;
+}
+void* inplace_XExtensionInfo_enlarge(void* a)
+{
+    if(!a) return a;
+    my_XExtensionInfo_32_t* src = a;
+    my_XExtensionInfo_t* dst = a;
+
+    dst->ndisplays = src->ndisplays;
+    dst->cur = from_ptrv(src->cur);
+    dst->head = from_ptrv(src->head);
+    my_XExtDisplayInfo_t* head = dst->head;
+    while(head) {
+        inplace_XExtDisplayInfo_enlarge(head);
+        head = head->next;
+    }
+    return a;
+}
+
+void convert_XFontProp_to_32(my_XFontProp_32_t* dst, my_XFontProp_t* src)
+{
+    dst->name = to_ulong(src->name);
+    dst->card32 = to_ulong(src->card32);
+}
+void inplace_XFontProp_shrink(void* a)
+{
+    if(!a) return;
+    my_XFontProp_t* src = a;
+    my_XFontProp_32_t* dst = a;
+    convert_XFontProp_to_32(dst, src);
+}
+void convert_XFontProp_to_64(my_XFontProp_t* dst, my_XFontProp_32_t* src)
+{
+    dst->card32 = from_ulong(src->card32);
+    dst->name = from_ulong(src->name);
+}
+void inplace_XFontProp_enlarge(void* a)
+{
+    if(!a) return;
+    my_XFontProp_32_t* src = a;
+    my_XFontProp_t* dst = a;
+    convert_XFontProp_to_64(dst, src);
+}
+void inplace_XFontStruct_shrink(void* a)
+{
+    if(!a) return;
+    my_XFontStruct_t* src = a;
+    my_XFontStruct_32_t* dst = a;
+
+    my_XFontProp_32_t* properties_s = (my_XFontProp_32_t*)src->properties;
+    for(int i=0; i<src->n_properties; ++i)
+        convert_XFontProp_to_32(properties_s+i, src->properties+i);
+
+    dst->ext_data = to_ptrv(src->ext_data);
+    dst->fid = to_ulong(src->fid);
+    dst->direction = src->direction;
+    dst->min_char_or_byte2 = src->min_char_or_byte2;
+    dst->max_char_or_byte2 = src->max_char_or_byte2;
+    dst->min_byte1 = src->min_byte1;
+    dst->max_byte1 = src->max_byte1;
+    dst->all_chars_exist = src->all_chars_exist;
+    dst->default_char = src->default_char;
+    dst->n_properties = src->n_properties;
+    dst->properties = to_ptrv(src->properties);
+    memmove(&dst->min_bounds, &src->min_bounds, sizeof(dst->min_bounds));
+    memmove(&dst->max_bounds, &src->max_bounds, sizeof(dst->max_bounds));
+    dst->per_char = to_ptrv(src->per_char);
+    dst->ascent = src->ascent;
+    dst->descent = src->descent;
+}
+void inplace_XFontStruct_enlarge(void* a)
+{
+    if(!a) return;
+    my_XFontStruct_32_t* src = a;
+    my_XFontStruct_t* dst = a;
+
+    dst->descent = src->descent;
+    dst->ascent = src->ascent;
+    dst->per_char = from_ptrv(src->per_char);
+    memmove(&dst->max_bounds, &src->max_bounds, sizeof(dst->max_bounds));
+    memmove(&dst->min_bounds, &src->min_bounds, sizeof(dst->min_bounds));
+    dst->properties = from_ptrv(src->properties);
+    dst->n_properties = src->n_properties;
+    dst->default_char = src->default_char;
+    dst->all_chars_exist = src->all_chars_exist;
+    dst->max_byte1 = src->max_byte1;
+    dst->min_byte1 = src->min_byte1;
+    dst->max_char_or_byte2 = src->max_char_or_byte2;
+    dst->min_char_or_byte2 = src->min_char_or_byte2;
+    dst->direction = src->direction;
+    dst->fid = from_ulong(src->fid);
+    dst->ext_data = from_ptrv(src->ext_data);
+
+    my_XFontProp_32_t* properties_s = (my_XFontProp_32_t*)dst->properties;
+    for(int i=dst->n_properties-1; i>=0;  --i)
+        convert_XFontProp_to_64(dst->properties+i, properties_s+i);
+}
diff --git a/src/libtools/my_x11_conv.h b/src/libtools/my_x11_conv.h
new file mode 100644
index 00000000..ccd9e497
--- /dev/null
+++ b/src/libtools/my_x11_conv.h
@@ -0,0 +1,52 @@
+#ifndef MY_X11_CONV
+#define MY_X11_CONV
+#include <stdint.h>
+
+#include "box32.h"
+#include "converter32.h"
+#include "my_x11_defs.h"
+#include "my_x11_defs_32.h"
+
+void convertXEvent(my_XEvent_32_t* dst, my_XEvent_t* src);
+void unconvertXEvent(my_XEvent_t* dst, my_XEvent_32_t* src);
+void* addDisplay(void* d);  // Adde new Native Display*, return a 32bits one
+void* FindDisplay(void* d); // Find a Native Diplay* and return the 32bits one
+void* getDisplay(void* d); // return the Native Display from a 32bits one
+void delDisplay(void* d); // removed a 32bits Display and associated ressources
+
+void convert_Screen_to_32(void* d, void* s);
+
+void convert_XWMints_to_64(void* d, void* s);
+void inplace_enlarge_wmhints(void* hints);
+void inplace_shrink_wmhints(void* hints);
+void convert_XSizeHints_to_64(void* d, void *s);
+void inplace_enlarge_wmsizehints(void* hints);
+void inplace_shrink_wmsizehints(void* hints);
+
+void convert_XWindowAttributes_to_32(void* d, void* s);
+
+void inplace_XModifierKeymap_shrink(void* a);
+void inplace_XModifierKeymap_enlarge(void* a);
+
+void convert_XVisualInfo_to_32(my_XVisualInfo_32_t* dst, my_XVisualInfo_t* src);
+void convert_XVisualInfo_to_64(my_XVisualInfo_t* dst, my_XVisualInfo_32_t* src);
+void inplace_XVisualInfo_shrink(void *a);
+void inplace_XVisualInfo_enlarge(void *a);
+
+void inplace_XdbeVisualInfo_shrink(void* a);
+void inplace_XdbeScreenVisualInfo_shrink(void* a);
+void inplace_XdbeVisualInfo_enlarge(void* a);
+void inplace_XdbeScreenVisualInfo_enlarge(void* a);
+
+void inplace_XExtDisplayInfo_shrink(void* a);
+void inplace_XExtDisplayInfo_enlarge(void* a);
+void* inplace_XExtensionInfo_shrink(void* a);
+void* inplace_XExtensionInfo_enlarge(void* a);
+
+void convert_XFontProp_to_32(my_XFontProp_32_t* dst, my_XFontProp_t* src);
+void convert_XFontProp_to_64(my_XFontProp_t* dst, my_XFontProp_32_t* src);
+void inplace_XFontProp_shrink(void* a);
+void inplace_XFontProp_enlarge(void* a);
+void inplace_XFontStruct_shrink(void* a);
+void inplace_XFontStruct_enlarge(void* a);
+#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 483046f0..a8fde6e2 100644
--- a/src/libtools/my_x11_defs.h
+++ b/src/libtools/my_x11_defs.h
@@ -961,4 +961,71 @@ typedef struct my_XcursorCursors_s {
     void*      cursors; //Cursor*
 } my_XcursorCursors_t;
 
+typedef struct my_XExtCodes_s {
+    int extension;
+    int major_opcode;
+    int first_event;
+    int first_error;
+} my_XExtCodes_t;
+
+typedef struct my_XExtDisplayInfo_s {
+    struct my_XExtDisplayInfo_s *next;
+    void*   display;    //Didsplay*
+    my_XExtCodes_t *codes;
+    void* data;
+} my_XExtDisplayInfo_t;
+
+typedef struct my_XExtensionInfo_s {
+    my_XExtDisplayInfo_t *head;
+    my_XExtDisplayInfo_t *cur;
+    int ndisplays;
+} my_XExtensionInfo_t;
+
+typedef struct my_XCharStruct_s {
+    short       lbearing;
+    short       rbearing;
+    short       width;
+    short       ascent;
+    short       descent;
+    unsigned short attributes;
+} my_XCharStruct_t;
+
+typedef struct my_XFontProp_s {
+    XID name;
+    unsigned long card32;
+} my_XFontProp_t;
+
+typedef struct my_XFontStruct_s {
+    void*             ext_data; //XExtData*
+    XID               fid;
+    unsigned          direction;
+    unsigned          min_char_or_byte2;
+    unsigned          max_char_or_byte2;
+    unsigned          min_byte1;
+    unsigned          max_byte1;
+    int               all_chars_exist;
+    unsigned          default_char;
+    int               n_properties;
+    my_XFontProp_t*   properties;
+    my_XCharStruct_t  min_bounds;
+    my_XCharStruct_t  max_bounds;
+    my_XCharStruct_t* per_char;
+    int               ascent;
+    int               descent;
+} my_XFontStruct_t;
+
+typedef struct my_XExtensionHooks_s {
+    int (*create_gc)(void* dpy, void* gc, my_XExtCodes_t* e);
+    int (*copy_gc)(void* dpy, void* gc, my_XExtCodes_t* e);
+    int (*flush_gc)(void* dpy, void* gc, my_XExtCodes_t* e);
+    int (*free_gc)(void* dpy, void* gc, my_XExtCodes_t* e);
+    int (*create_font)(void* dpy, my_XFontStruct_t* f, my_XExtCodes_t* e);
+    int (*free_font)(void* dpy, my_XFontStruct_t* f, my_XExtCodes_t* e);
+    int (*close_display)(void* dpy, my_XExtCodes_t* e);
+    int (*wire_to_event)(void* dpy, my_XEvent_t* evt, void* xEvent);
+    int (*event_to_wire)(void* dpy, my_XEvent_t* evt, void* xEvent);
+    int (*error)(void* dpy, void* xError, my_XExtCodes_t* e, int* n);
+    char*(*error_string)(void* dpy, int, my_XExtCodes_t* e, char* s, int n);
+} my_XExtensionHooks_t;
+
 #endif//MY_X11_DEFS
\ No newline at end of file
diff --git a/src/libtools/my_x11_defs_32.h b/src/libtools/my_x11_defs_32.h
index 5599af18..10e3ce23 100644
--- a/src/libtools/my_x11_defs_32.h
+++ b/src/libtools/my_x11_defs_32.h
@@ -894,4 +894,71 @@ typedef struct my_XcursorCursors_32_s {
     ptr_t      cursors; //Cursor*
 } my_XcursorCursors_32_t;
 
+typedef struct my_XExtCodes_32_s {
+    int extension;
+    int major_opcode;
+    int first_event;
+    int first_error;
+} my_XExtCodes_32_t;
+
+typedef struct my_XExtDisplayInfo_32_s {
+    ptr_t   next; //struct my_XExtDisplayInfo_s*
+    ptr_t   display;    //Didsplay*
+    ptr_t   codes; //my_XExtCodes_t*
+    ptr_t   data;   //void*
+} my_XExtDisplayInfo_32_t;
+
+typedef struct my_XExtensionInfo_32_s {
+    ptr_t head; //my_XExtDisplayInfo_t*
+    ptr_t cur;  //my_XExtDisplayInfo_t*
+    int   ndisplays;
+} my_XExtensionInfo_32_t;
+
+typedef struct my_XCharStruct_32_t {
+    short       lbearing;
+    short       rbearing;
+    short       width;
+    short       ascent;
+    short       descent;
+    unsigned short attributes;
+} my_XCharStruct_32_t;
+
+typedef struct my_XFontProp_32_s {
+    XID_32  name;
+    ulong_t card32;
+} my_XFontProp_32_t;
+
+typedef struct my_XFontStruct_32_s {
+    ptr_t                   ext_data; //XExtData*
+    XID_32                  fid;
+    unsigned                direction;
+    unsigned                min_char_or_byte2;
+    unsigned                max_char_or_byte2;
+    unsigned                min_byte1;
+    unsigned                max_byte1;
+    int                     all_chars_exist;
+    unsigned                default_char;
+    int                     n_properties;
+    ptr_t                   properties;   //my_XFontProp_t*
+    my_XCharStruct_32_t     min_bounds;
+    my_XCharStruct_32_t     max_bounds;
+    ptr_t                   per_char; //my_XCharStruct_t*
+    int                     ascent;
+    int                     descent;
+} my_XFontStruct_32_t;
+
+typedef struct my_XExtensionHooks_32_s {
+    ptr_t create_gc; //int (*create_gc)(void* dpy, void* gc, my_XExtCodes_t* e);
+    ptr_t copy_gc; //int (*copy_gc)(void* dpy, void* gc, my_XExtCodes_t* e);
+    ptr_t flush_gc; //int (*flush_gc)(void* dpy, void* gc, my_XExtCodes_t* e);
+    ptr_t free_gc; //int (*free_gc)(void* dpy, void* gc, my_XExtCodes_t* e);
+    ptr_t create_font; //int (*create_font)(void* dpy, my_XFontStruct_t* f, my_XExtCodes_t* e);
+    ptr_t free_font; //int (*free_font)(void* dpy, my_XFontStruct_t* f, my_XExtCodes_t* e);
+    ptr_t close_display; //int (*close_display)(void* dpy, my_XExtCodes_t* e);
+    ptr_t wire_to_event; //int (*wire_to_event)(void* dpy, my_XEvent_t* evt, void* xEvent);
+    ptr_t event_to_wire; //int (*event_to_wire)(void* dpy, my_XEvent_t* evt, void* xEvent);
+    ptr_t error; //int (*error)(void* dpy, void* xError, my_XExtCodes_t* e, int* n);
+    ptr_t error_string; //char*(*error_string)(void* dpy, int, my_XExtCodes_t* e, char* s, int n);
+} my_XExtensionHooks_32_t;
+
 #endif//MY_X11_DEFS_32
\ No newline at end of file
diff --git a/src/wrapped32/generated/functions_list.txt b/src/wrapped32/generated/functions_list.txt
index f20dfde5..1e503a94 100644
--- a/src/wrapped32/generated/functions_list.txt
+++ b/src/wrapped32/generated/functions_list.txt
@@ -388,6 +388,7 @@
 #() iFEpL -> iFEpL
 #() iFEpp -> iFEpp
 #() iFEpV -> iFEpV
+#() iFEpX -> iFEpX
 #() iFEhi -> iFEhi
 #() iFEhp -> iFEhp
 #() iFEXp -> iFEXp
@@ -501,6 +502,7 @@
 #() pFEpi -> pFEpi
 #() pFEpp -> pFEpp
 #() pFEpV -> pFEpV
+#() pFEpX -> pFEpX
 #() pFEXi -> pFEXi
 #() pFEXL -> pFEXL
 #() pFEXp -> pFEXp
@@ -710,6 +712,7 @@
 #() iFESpp -> iFESpp
 #() iFESpV -> iFESpV
 #() iFEXip -> iFEXip
+#() iFEXlp -> iFEXlp
 #() iFEXLp -> iFEXLp
 #() iFiiii -> iFiiii
 #() iFiiiu -> iFiiiu
@@ -1272,6 +1275,7 @@
 #() pFEpLiiii -> pFEpLiiii
 #() pFEpLiiiI -> pFEpLiiiI
 #() pFEpLiiil -> pFEpLiiil
+#() pFEpXppip -> pFEpXppip
 #() vFXLLiiibl_ -> vFXLLiiiB
 #() iFXiLibiip_ip -> iFXiLiBip
 #() iFXLibL_ubL_u -> iFXLiBuBu
@@ -2005,6 +2009,8 @@ wrappedlibx11:
   - XSetIMValues
 - pFXi:
   - XSynchronize
+- pFXL:
+  - XGetWMHints
 - pFXp:
   - XListExtensions
 - vFXLp:
@@ -2013,6 +2019,8 @@ wrappedlibx11:
   - XStringListToTextProperty
 - iFXip:
   - XCheckTypedEvent
+- iFXlp:
+  - XMaskEvent
 - iFXLp:
   - XGetWindowAttributes
   - XSetWMHints
@@ -2020,6 +2028,8 @@ wrappedlibx11:
   - XGetPixel
 - pFXip:
   - XESetCloseDisplay
+  - XESetEventToWire
+  - XESetWireToEvent
 - iFpLlp:
   - XWindowEvent
 - iFXLip:
@@ -2084,12 +2094,21 @@ wrappedlibxcursor:
 wrappedlibxext:
 - vFp:
   - XdbeFreeVisualInfo
+  - XextDestroyExtension
+- pFv:
+  - XextCreateExtension
 - pFp:
   - XSetExtensionErrorHandler
+- iFpX:
+  - XextRemoveDisplay
+- pFpX:
+  - XextFindDisplay
 - pFXpp:
   - XdbeGetVisualInfo
 - iFXLpiiL:
   - XShmGetImage
+- pFpXppip:
+  - XextAddDisplay
 - pFXbpLiLLLii_uipbLipi_uu:
   - XShmCreateImage
 - iFXLppiiiiuui:
diff --git a/src/wrapped32/generated/wrappedlibx11types32.h b/src/wrapped32/generated/wrappedlibx11types32.h
index 6f292dc4..b5974d1b 100644
--- a/src/wrapped32/generated/wrappedlibx11types32.h
+++ b/src/wrapped32/generated/wrappedlibx11types32.h
@@ -23,10 +23,12 @@ typedef uintptr_t (*LFpi_t)(void*, int32_t);
 typedef void* (*pFiV_t)(int32_t, ...);
 typedef void* (*pFpV_t)(void*, ...);
 typedef void* (*pFXi_t)(void*, int32_t);
+typedef void* (*pFXL_t)(void*, uintptr_t);
 typedef void* (*pFXp_t)(void*, void*);
 typedef void (*vFXLp_t)(void*, uintptr_t, void*);
 typedef int32_t (*iFpip_t)(void*, int32_t, void*);
 typedef int32_t (*iFXip_t)(void*, int32_t, void*);
+typedef int32_t (*iFXlp_t)(void*, intptr_t, void*);
 typedef int32_t (*iFXLp_t)(void*, uintptr_t, void*);
 typedef uintptr_t (*LFXii_t)(void*, int32_t, int32_t);
 typedef void* (*pFXip_t)(void*, int32_t, void*);
@@ -80,14 +82,18 @@ typedef uintptr_t (*LFXLiiuuuiupLp_t)(void*, uintptr_t, int32_t, int32_t, uint32
 	GO(XSetICValues, pFpV_t) \
 	GO(XSetIMValues, pFpV_t) \
 	GO(XSynchronize, pFXi_t) \
+	GO(XGetWMHints, pFXL_t) \
 	GO(XListExtensions, pFXp_t) \
 	GO(XSetWMNormalHints, vFXLp_t) \
 	GO(XStringListToTextProperty, iFpip_t) \
 	GO(XCheckTypedEvent, iFXip_t) \
+	GO(XMaskEvent, iFXlp_t) \
 	GO(XGetWindowAttributes, iFXLp_t) \
 	GO(XSetWMHints, iFXLp_t) \
 	GO(XGetPixel, LFXii_t) \
 	GO(XESetCloseDisplay, pFXip_t) \
+	GO(XESetEventToWire, pFXip_t) \
+	GO(XESetWireToEvent, pFXip_t) \
 	GO(XWindowEvent, iFpLlp_t) \
 	GO(XCheckTypedWindowEvent, iFXLip_t) \
 	GO(XCheckWindowEvent, iFXLlp_t) \
diff --git a/src/wrapped32/generated/wrappedlibxexttypes32.h b/src/wrapped32/generated/wrappedlibxexttypes32.h
index fa6d4f69..9f95f95b 100644
--- a/src/wrapped32/generated/wrappedlibxexttypes32.h
+++ b/src/wrapped32/generated/wrappedlibxexttypes32.h
@@ -12,17 +12,26 @@
 #endif
 
 typedef void (*vFp_t)(void*);
+typedef void* (*pFv_t)(void);
 typedef void* (*pFp_t)(void*);
+typedef int32_t (*iFpX_t)(void*, void*);
+typedef void* (*pFpX_t)(void*, void*);
 typedef void* (*pFXpp_t)(void*, void*, void*);
 typedef int32_t (*iFXLpiiL_t)(void*, uintptr_t, void*, int32_t, int32_t, uintptr_t);
+typedef void* (*pFpXppip_t)(void*, void*, void*, void*, int32_t, void*);
 typedef void* (*pFXbpLiLLLii_uipbLipi_uu_t)(void*, struct_pLiLLLii_t*, uint32_t, int32_t, void*, struct_Lipi_t*, uint32_t, uint32_t);
 typedef int32_t (*iFXLppiiiiuui_t)(void*, uintptr_t, void*, void*, int32_t, int32_t, int32_t, int32_t, uint32_t, uint32_t, int32_t);
 
 #define SUPER() ADDED_FUNCTIONS() \
 	GO(XdbeFreeVisualInfo, vFp_t) \
+	GO(XextDestroyExtension, vFp_t) \
+	GO(XextCreateExtension, pFv_t) \
 	GO(XSetExtensionErrorHandler, pFp_t) \
+	GO(XextRemoveDisplay, iFpX_t) \
+	GO(XextFindDisplay, pFpX_t) \
 	GO(XdbeGetVisualInfo, pFXpp_t) \
 	GO(XShmGetImage, iFXLpiiL_t) \
+	GO(XextAddDisplay, pFpXppip_t) \
 	GO(XShmCreateImage, pFXbpLiLLLii_uipbLipi_uu_t) \
 	GO(XShmPutImage, iFXLppiiiiuui_t)
 
diff --git a/src/wrapped32/generated/wrapper32.c b/src/wrapped32/generated/wrapper32.c
index f2f0a602..3e2962d5 100644
--- a/src/wrapped32/generated/wrapper32.c
+++ b/src/wrapped32/generated/wrapper32.c
@@ -478,6 +478,7 @@ typedef int32_t (*iFEpl_t)(x64emu_t*, void*, intptr_t);
 typedef int32_t (*iFEpL_t)(x64emu_t*, void*, uintptr_t);
 typedef int32_t (*iFEpp_t)(x64emu_t*, void*, void*);
 typedef int32_t (*iFEpV_t)(x64emu_t*, void*, void*);
+typedef int32_t (*iFEpX_t)(x64emu_t*, void*, void*);
 typedef int32_t (*iFEhi_t)(x64emu_t*, uintptr_t, int32_t);
 typedef int32_t (*iFEhp_t)(x64emu_t*, uintptr_t, void*);
 typedef int32_t (*iFEXp_t)(x64emu_t*, void*, void*);
@@ -591,6 +592,7 @@ typedef void* (*pFEiV_t)(x64emu_t*, int32_t, void*);
 typedef void* (*pFEpi_t)(x64emu_t*, void*, int32_t);
 typedef void* (*pFEpp_t)(x64emu_t*, void*, void*);
 typedef void* (*pFEpV_t)(x64emu_t*, void*, void*);
+typedef void* (*pFEpX_t)(x64emu_t*, void*, void*);
 typedef void* (*pFEXi_t)(x64emu_t*, void*, int32_t);
 typedef void* (*pFEXL_t)(x64emu_t*, void*, uintptr_t);
 typedef void* (*pFEXp_t)(x64emu_t*, void*, void*);
@@ -800,6 +802,7 @@ typedef int32_t (*iFEhup_t)(x64emu_t*, uintptr_t, uint32_t, void*);
 typedef int32_t (*iFESpp_t)(x64emu_t*, void*, void*, void*);
 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 (*iFiiii_t)(int32_t, int32_t, int32_t, int32_t);
 typedef int32_t (*iFiiiu_t)(int32_t, int32_t, int32_t, uint32_t);
@@ -1362,6 +1365,7 @@ typedef void* (*pFEpiiiiu_t)(x64emu_t*, void*, int32_t, int32_t, int32_t, int32_
 typedef void* (*pFEpLiiii_t)(x64emu_t*, void*, uintptr_t, int32_t, int32_t, int32_t, int32_t);
 typedef void* (*pFEpLiiiI_t)(x64emu_t*, void*, uintptr_t, int32_t, int32_t, int32_t, int64_t);
 typedef void* (*pFEpLiiil_t)(x64emu_t*, void*, uintptr_t, int32_t, int32_t, int32_t, intptr_t);
+typedef void* (*pFEpXppip_t)(x64emu_t*, void*, void*, void*, void*, int32_t, void*);
 typedef void (*vFXLLiiibl__t)(void*, uintptr_t, uintptr_t, int32_t, int32_t, int32_t, struct_l_t*);
 typedef int32_t (*iFXiLibiip_ip_t)(void*, int32_t, uintptr_t, int32_t, struct_iip_t*, int32_t, void*);
 typedef int32_t (*iFXLibL_ubL_u_t)(void*, uintptr_t, int32_t, struct_L_t*, uint32_t, struct_L_t*, uint32_t);
@@ -1953,6 +1957,7 @@ void iFEpl_32(x64emu_t *emu, uintptr_t fcn) { iFEpl_t fn = (iFEpl_t)fcn; R_EAX =
 void iFEpL_32(x64emu_t *emu, uintptr_t fcn) { iFEpL_t fn = (iFEpL_t)fcn; R_EAX = fn(emu, from_ptriv(R_ESP + 4), from_ulong(from_ptri(ulong_t, R_ESP + 8))); }
 void iFEpp_32(x64emu_t *emu, uintptr_t fcn) { iFEpp_t fn = (iFEpp_t)fcn; R_EAX = fn(emu, from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8)); }
 void iFEpV_32(x64emu_t *emu, uintptr_t fcn) { iFEpV_t fn = (iFEpV_t)fcn; R_EAX = fn(emu, from_ptriv(R_ESP + 4), from_ptrv(R_ESP + 8)); }
+void iFEpX_32(x64emu_t *emu, uintptr_t fcn) { iFEpX_t fn = (iFEpX_t)fcn; R_EAX = fn(emu, from_ptriv(R_ESP + 4), getDisplay(from_ptriv(R_ESP + 8))); }
 void iFEhi_32(x64emu_t *emu, uintptr_t fcn) { iFEhi_t fn = (iFEhi_t)fcn; R_EAX = fn(emu, from_hash(from_ptri(ptr_t, R_ESP + 4)), from_ptri(int32_t, R_ESP + 8)); }
 void iFEhp_32(x64emu_t *emu, uintptr_t fcn) { iFEhp_t fn = (iFEhp_t)fcn; R_EAX = fn(emu, from_hash(from_ptri(ptr_t, R_ESP + 4)), from_ptriv(R_ESP + 8)); }
 void iFEXp_32(x64emu_t *emu, uintptr_t fcn) { iFEXp_t fn = (iFEXp_t)fcn; R_EAX = fn(emu, getDisplay(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8)); }
@@ -2066,6 +2071,7 @@ void pFEiV_32(x64emu_t *emu, uintptr_t fcn) { pFEiV_t fn = (pFEiV_t)fcn; R_EAX =
 void pFEpi_32(x64emu_t *emu, uintptr_t fcn) { pFEpi_t fn = (pFEpi_t)fcn; R_EAX = to_ptrv(fn(emu, from_ptriv(R_ESP + 4), from_ptri(int32_t, R_ESP + 8))); }
 void pFEpp_32(x64emu_t *emu, uintptr_t fcn) { pFEpp_t fn = (pFEpp_t)fcn; R_EAX = to_ptrv(fn(emu, from_ptriv(R_ESP + 4), from_ptriv(R_ESP + 8))); }
 void pFEpV_32(x64emu_t *emu, uintptr_t fcn) { pFEpV_t fn = (pFEpV_t)fcn; R_EAX = to_ptrv(fn(emu, from_ptriv(R_ESP + 4), from_ptrv(R_ESP + 8))); }
+void pFEpX_32(x64emu_t *emu, uintptr_t fcn) { pFEpX_t fn = (pFEpX_t)fcn; R_EAX = to_ptrv(fn(emu, from_ptriv(R_ESP + 4), getDisplay(from_ptriv(R_ESP + 8)))); }
 void pFEXi_32(x64emu_t *emu, uintptr_t fcn) { pFEXi_t fn = (pFEXi_t)fcn; R_EAX = to_ptrv(fn(emu, getDisplay(from_ptriv(R_ESP + 4)), from_ptri(int32_t, R_ESP + 8))); }
 void pFEXL_32(x64emu_t *emu, uintptr_t fcn) { pFEXL_t fn = (pFEXL_t)fcn; R_EAX = to_ptrv(fn(emu, getDisplay(from_ptriv(R_ESP + 4)), from_ulong(from_ptri(ulong_t, R_ESP + 8)))); }
 void pFEXp_32(x64emu_t *emu, uintptr_t fcn) { pFEXp_t fn = (pFEXp_t)fcn; R_EAX = to_ptrv(fn(emu, getDisplay(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8))); }
@@ -2275,6 +2281,7 @@ void iFEhup_32(x64emu_t *emu, uintptr_t fcn) { iFEhup_t fn = (iFEhup_t)fcn; R_EA
 void iFESpp_32(x64emu_t *emu, uintptr_t fcn) { iFESpp_t fn = (iFESpp_t)fcn; R_EAX = fn(emu, io_convert32(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8), from_ptriv(R_ESP + 12)); }
 void iFESpV_32(x64emu_t *emu, uintptr_t fcn) { iFESpV_t fn = (iFESpV_t)fcn; R_EAX = fn(emu, io_convert32(from_ptriv(R_ESP + 4)), from_ptriv(R_ESP + 8), from_ptrv(R_ESP + 12)); }
 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 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)); }
@@ -2837,6 +2844,7 @@ void pFEpiiiiu_32(x64emu_t *emu, uintptr_t fcn) { pFEpiiiiu_t fn = (pFEpiiiiu_t)
 void pFEpLiiii_32(x64emu_t *emu, uintptr_t fcn) { pFEpLiiii_t fn = (pFEpLiiii_t)fcn; R_EAX = to_ptrv(fn(emu, from_ptriv(R_ESP + 4), from_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24))); }
 void pFEpLiiiI_32(x64emu_t *emu, uintptr_t fcn) { pFEpLiiiI_t fn = (pFEpLiiiI_t)fcn; R_EAX = to_ptrv(fn(emu, from_ptriv(R_ESP + 4), from_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int64_t, R_ESP + 24))); }
 void pFEpLiiil_32(x64emu_t *emu, uintptr_t fcn) { pFEpLiiil_t fn = (pFEpLiiil_t)fcn; R_EAX = to_ptrv(fn(emu, from_ptriv(R_ESP + 4), from_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptri(int32_t, R_ESP + 12), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_long(from_ptri(long_t, R_ESP + 24)))); }
+void pFEpXppip_32(x64emu_t *emu, uintptr_t fcn) { pFEpXppip_t fn = (pFEpXppip_t)fcn; R_EAX = to_ptrv(fn(emu, from_ptriv(R_ESP + 4), getDisplay(from_ptriv(R_ESP + 8)), from_ptriv(R_ESP + 12), from_ptriv(R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptriv(R_ESP + 24))); }
 void vFXLLiiibl__32(x64emu_t *emu, uintptr_t fcn) { vFXLLiiibl__t fn = (vFXLLiiibl__t)fcn; struct_l_t arg_28={0}; if (*(ptr_t*)(from_ptr((R_ESP + 28)))) from_struct_l(&arg_28, *(ptr_t*)(from_ptr((R_ESP + 28)))); fn(getDisplay(from_ptriv(R_ESP + 4)), from_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ulong(from_ptri(ulong_t, R_ESP + 12)), from_ptri(int32_t, R_ESP + 16), from_ptri(int32_t, R_ESP + 20), from_ptri(int32_t, R_ESP + 24), *(ptr_t*)(from_ptr((R_ESP + 28))) ? &arg_28 : NULL); if (*(ptr_t*)(from_ptr((R_ESP + 28)))) to_struct_l(*(ptr_t*)(from_ptr((R_ESP + 28))), &arg_28); }
 void iFXiLibiip_ip_32(x64emu_t *emu, uintptr_t fcn) { iFXiLibiip_ip_t fn = (iFXiLibiip_ip_t)fcn; struct_iip_t arg_20={0}; if (*(ptr_t*)(from_ptr((R_ESP + 20)))) from_struct_iip(&arg_20, *(ptr_t*)(from_ptr((R_ESP + 20)))); R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), from_ptri(int32_t, R_ESP + 8), from_ulong(from_ptri(ulong_t, R_ESP + 12)), from_ptri(int32_t, R_ESP + 16), *(ptr_t*)(from_ptr((R_ESP + 20))) ? &arg_20 : NULL, from_ptri(int32_t, R_ESP + 24), from_ptriv(R_ESP + 28)); if (*(ptr_t*)(from_ptr((R_ESP + 20)))) to_struct_iip(*(ptr_t*)(from_ptr((R_ESP + 20))), &arg_20); }
 void iFXLibL_ubL_u_32(x64emu_t *emu, uintptr_t fcn) { iFXLibL_ubL_u_t fn = (iFXLibL_ubL_u_t)fcn; struct_L_t arg_16={0}; if (*(ptr_t*)(from_ptr((R_ESP + 16)))) from_struct_L(&arg_16, *(ptr_t*)(from_ptr((R_ESP + 16)))); struct_L_t arg_24={0}; if (*(ptr_t*)(from_ptr((R_ESP + 24)))) from_struct_L(&arg_24, *(ptr_t*)(from_ptr((R_ESP + 24)))); R_EAX = fn(getDisplay(from_ptriv(R_ESP + 4)), from_ulong(from_ptri(ulong_t, R_ESP + 8)), from_ptri(int32_t, R_ESP + 12), *(ptr_t*)(from_ptr((R_ESP + 16))) ? &arg_16 : NULL, from_ptri(uint32_t, R_ESP + 20), *(ptr_t*)(from_ptr((R_ESP + 24))) ? &arg_24 : NULL, from_ptri(uint32_t, R_ESP + 28)); if (*(ptr_t*)(from_ptr((R_ESP + 16)))) to_struct_L(*(ptr_t*)(from_ptr((R_ESP + 16))), &arg_16); if (*(ptr_t*)(from_ptr((R_ESP + 24)))) to_struct_L(*(ptr_t*)(from_ptr((R_ESP + 24))), &arg_24); }
diff --git a/src/wrapped32/generated/wrapper32.h b/src/wrapped32/generated/wrapper32.h
index c5d842d5..7b29d9a8 100644
--- a/src/wrapped32/generated/wrapper32.h
+++ b/src/wrapped32/generated/wrapper32.h
@@ -429,6 +429,7 @@ void iFEpl_32(x64emu_t *emu, uintptr_t fnc);
 void iFEpL_32(x64emu_t *emu, uintptr_t fnc);
 void iFEpp_32(x64emu_t *emu, uintptr_t fnc);
 void iFEpV_32(x64emu_t *emu, uintptr_t fnc);
+void iFEpX_32(x64emu_t *emu, uintptr_t fnc);
 void iFEhi_32(x64emu_t *emu, uintptr_t fnc);
 void iFEhp_32(x64emu_t *emu, uintptr_t fnc);
 void iFEXp_32(x64emu_t *emu, uintptr_t fnc);
@@ -542,6 +543,7 @@ void pFEiV_32(x64emu_t *emu, uintptr_t fnc);
 void pFEpi_32(x64emu_t *emu, uintptr_t fnc);
 void pFEpp_32(x64emu_t *emu, uintptr_t fnc);
 void pFEpV_32(x64emu_t *emu, uintptr_t fnc);
+void pFEpX_32(x64emu_t *emu, uintptr_t fnc);
 void pFEXi_32(x64emu_t *emu, uintptr_t fnc);
 void pFEXL_32(x64emu_t *emu, uintptr_t fnc);
 void pFEXp_32(x64emu_t *emu, uintptr_t fnc);
@@ -751,6 +753,7 @@ void iFEhup_32(x64emu_t *emu, uintptr_t fnc);
 void iFESpp_32(x64emu_t *emu, uintptr_t fnc);
 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 iFiiii_32(x64emu_t *emu, uintptr_t fnc);
 void iFiiiu_32(x64emu_t *emu, uintptr_t fnc);
@@ -1313,6 +1316,7 @@ void pFEpiiiiu_32(x64emu_t *emu, uintptr_t fnc);
 void pFEpLiiii_32(x64emu_t *emu, uintptr_t fnc);
 void pFEpLiiiI_32(x64emu_t *emu, uintptr_t fnc);
 void pFEpLiiil_32(x64emu_t *emu, uintptr_t fnc);
+void pFEpXppip_32(x64emu_t *emu, uintptr_t fnc);
 void vFXLLiiibl__32(x64emu_t *emu, uintptr_t fnc);
 void iFXiLibiip_ip_32(x64emu_t *emu, uintptr_t fnc);
 void iFXLibL_ubL_u_32(x64emu_t *emu, uintptr_t fnc);
diff --git a/src/wrapped32/wrappedlibx11.c b/src/wrapped32/wrappedlibx11.c
index 9f44cd39..818c21bd 100644
--- a/src/wrapped32/wrappedlibx11.c
+++ b/src/wrapped32/wrappedlibx11.c
@@ -27,11 +27,8 @@
 
 #define LIBNAME libx11
 
-#include "libtools/my_x11_defs.h"
-#include "libtools/my_x11_defs_32.h"
+#include "libtools/my_x11_conv.h"
 
-void convertXEvent(my_XEvent_32_t* dst, my_XEvent_t* src);
-void unconvertXEvent(my_XEvent_t* dst, my_XEvent_32_t* src);
 typedef int (*XErrorHandler)(void *, void *);
 void* my32_XSetErrorHandler(x64emu_t* t, XErrorHandler handler);
 typedef int (*XIOErrorHandler)(void *);
@@ -93,13 +90,16 @@ GO(12)  \
 GO(13)  \
 GO(14)  \
 GO(15)
-#if 0
+
 // wire_to_event
 #define GO(A)   \
-static uintptr_t my32_wire_to_event_fct_##A = 0;                      \
-static int my32_wire_to_event_##A(void* dpy, void* re, void* event)   \
-{                                                                   \
-    return (int)RunFunctionFmt(my32_wire_to_event_fct_##A, "ppp", dpy, re, event);\
+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
@@ -124,15 +124,17 @@ static void* reverse_wire_to_eventFct(library_t* lib, void* fct)
     #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, fct, 0, NULL);
+    return (void*)AddBridge(lib->w.bridge, iFppp_32, fct, 0, NULL);
 }
 
 // event_to_wire
 #define GO(A)   \
-static uintptr_t my32_event_to_wire_fct_##A = 0;                      \
-static int my32_event_to_wire_##A(void* dpy, void* re, void* event)   \
-{                                                                   \
-    return (int)RunFunctionFmt(my32_event_to_wire_fct_##A, "ppp", dpy, re, event);\
+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
@@ -157,9 +159,8 @@ static void* reverse_event_to_wireFct(library_t* lib, void* fct)
     #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, fct, 0, NULL);
+    return (void*)AddBridge(lib->w.bridge, iFppp_32, fct, 0, NULL);
 }
-#endif
 // error_handler
 #define GO(A)   \
 static uintptr_t my32_error_handler_fct_##A = 0;                                            \
@@ -1500,6 +1501,7 @@ EXPORT void my32__XDeqAsyncHandler(x64emu_t* emu, void* cb, void* data)
     my->_XDeqAsyncHandler(findXInternalAsyncHandlerFct(cb), data);
 }
 
+#endif
 EXPORT void* my32_XESetWireToEvent(x64emu_t* emu, void* display, int32_t event_number, void* proc)
 {
     void* ret = NULL;
@@ -1516,7 +1518,6 @@ EXPORT void* my32_XESetEventToWire(x64emu_t* emu, void* display, int32_t event_n
 
     return reverse_event_to_wireFct(my_lib, ret);
 }
-#endif
 
 EXPORT int my32_XRegisterIMInstantiateCallback(x64emu_t* emu, void* d, void* db, void* res_name, void* res_class, void* cb, void* data)
 {
@@ -1560,170 +1561,10 @@ EXPORT void* my32_XSynchronize(x64emu_t* emu, void* display, int onoff)
     return reverse_XSynchronizeProcFct(my_lib, my->XSynchronize(display, onoff));
 }
 
-#define N_DISPLAY 4
-#define N_SCREENS 16
-my_XDisplay_t* my32_Displays_64[N_DISPLAY] = {0};
-struct my_XFreeFuncs_32 my32_free_funcs_32[N_DISPLAY] = {0};
-struct my_XLockPtrs_32 my32_lock_fns_32[N_DISPLAY] = {0};
-my_Screen_32_t my32_screens[N_DISPLAY*N_SCREENS] = {0};
-int n_screeens = 0;
-my_XDisplay_32_t my32_Displays_32[N_DISPLAY] = {0};
-
-void* getDisplay(void* d)
-{
-    if(!d) return d;
-    for(int i=0; i<N_DISPLAY; ++i)
-        if(((&my32_Displays_32[i])==d) || (my32_Displays_64[i]==d))
-            return my32_Displays_64[i];
-        printf_log(LOG_INFO, "BOX32: Warning, 32bits Display %p not found\n", d);
-    return d;
-}
-
-void* FindDisplay(void* d)
-{
-    if(!d) return d;
-    for(int i=0; i<N_DISPLAY; ++i)
-        if((my32_Displays_64[i]==d) || ((&my32_Displays_32[i])==d))
-            return &my32_Displays_32[i];
-    return d;
-}
-
-void convert_Screen_to_32(void* d, void* s)
-{
-    my_Screen_t* src = s;
-    my_Screen_32_t* dst = d;
-    dst->ext_data = to_ptrv(src->ext_data);
-    dst->display = to_ptrv(FindDisplay(src->display));
-    dst->root = to_ulong(src->root);
-    dst->width = src->width;
-    dst->mwidth = src->mwidth;
-    dst->ndepths = src->ndepths;
-    dst->depths = to_ptrv(src->depths);
-    dst->root_depth = src->root_depth;
-    dst->root_visual = to_ptrv(src->root_visual);
-    dst->default_gc = to_ptrv(src->default_gc);
-    dst->cmap = to_ulong(src->cmap);
-    dst->white_pixel = to_ulong(src->white_pixel);
-    dst->black_pixel = to_ulong(src->black_pixel);
-    dst->max_maps = src->max_maps;
-    dst->backing_store = src->backing_store;
-    dst->save_unders = src->save_unders;
-    dst->root_input_mask = to_long(src->root_input_mask);
-}
-
-void* my_dlopen(x64emu_t* emu, void *filename, int flag);
-void* addDisplay(void* d)
-{
-    if(!my_lib) {
-        // the lib has not be loaded directly... need to open it! leaking the lib handle...
-        #ifdef ANDROID
-        my_dlopen(thread_get_emu(), "libX11.so", RTLD_NOW);
-        #else
-        my_dlopen(thread_get_emu(), "libX11.so.6", RTLD_NOW);
-        #endif
-    }
-    my_XDisplay_t* dpy = (my_XDisplay_t*)d;
-    // look for a free slot, or a display already there
-    my_XDisplay_32_t* ret = NULL;
-    struct my_XFreeFuncs_32 *free_funcs = NULL;
-    struct my_XLockPtrs_32 *lock_fns = NULL;
-    for(int i=0; i<N_DISPLAY && !ret; ++i)
-        if(my32_Displays_64[i]==dpy)
-            return &my32_Displays_32[i];
-    for(int i=0; i<N_DISPLAY && !ret; ++i) {
-        if(!my32_Displays_64[i]) {
-            my32_Displays_64[i] = dpy;
-            ret = &my32_Displays_32[i];
-            free_funcs = &my32_free_funcs_32[i];
-            ret->free_funcs = to_ptrv(free_funcs);
-            lock_fns = &my32_lock_fns_32[i];
-            ret->lock_fns = to_ptrv(lock_fns);
-        }
-    }
-    if(!ret) {
-        printf_log(LOG_INFO, "BOX32: No more slot available for libX11 Display!");
-        return d;
-    }
-
-    bridge_t* system = my_lib->w.bridge;
-
-    // partial copy...
-
-    #define GO(A, W)\
-    if(dpy->A)      \
-        if(!CheckBridged(system, dpy->A)) \
-            ret->A = AddCheckBridge(system, W, dpy->A, 0, #A); \
-
-    #define GO2(A, B, W) \
-    if(dpy->A && dpy->A->B)  \
-        if(!CheckBridged(system, dpy->A->B)) \
-            A->B = AddCheckBridge(system, W, dpy->A->B, 0, #B "_" #A); \
-
-    ret->vendor = to_cstring(dpy->vendor);
-    ret->fd = dpy->fd;
-    ret->conn_checker = dpy->conn_checker;
-    ret->proto_major_version = dpy->proto_major_version;
-    ret->proto_minor_version = dpy->proto_minor_version;
-    ret->xdefaults = to_cstring(dpy->xdefaults);
-    ret->display_name = to_cstring(dpy->display_name);
-    ret->default_screen = dpy->default_screen;
-    ret->nscreens = dpy->nscreens;
-    if(dpy->screens) {
-        ret->screens = to_ptrv(&my32_screens[n_screeens]);
-        for(int i=0; i<dpy->nscreens; ++i) {
-            if(n_screeens==N_DISPLAY*N_SCREENS) {
-                printf_log(LOG_INFO, "BOX32: Warning, no more libX11 Screen slots!");
-                break;
-            }
-            convert_Screen_to_32(&my32_screens[n_screeens++], &dpy->screens[i]);
-        }
-    } else
-        ret->screens = 0;
-
-    GO2(free_funcs, atoms, vFp_32)
-    GO2(free_funcs, modifiermap, iFp_32)
-    GO2(free_funcs, key_bindings, vFp_32)
-    GO2(free_funcs, context_db, vFp_32)
-    GO2(free_funcs, defaultCCCs, vFp_32)
-    GO2(free_funcs, clientCmaps, vFp_32)
-    GO2(free_funcs, intensityMaps, vFp_32)
-    GO2(free_funcs, im_filters, vFp_32)
-    GO2(free_funcs, xkb, vFp_32)
-    GO(resource_alloc, LFp_32)
-    GO(synchandler, iFp_32)
-    //TODO: ext_procs?
-    //TODO: event_vec?
-    //TODO: wire_vec?
-    //TODO: async_handlers?
-    GO2(lock_fns, lock_display, vFp_32)
-    GO2(lock_fns, unlock_display, vFp_32)
-    GO(idlist_alloc, vFppi_32)
-    //TODO: error_vec?
-    //TODO: flushes
-    //TODO: im_fd_info?
-    //TODO: conn_watchers
-    GO(savedsynchandler, iFp_32)
-    //TODO: generic_event_vec?
-    //TODO: generic_event_copy_vec?
-
-
-    #undef GO
-    #undef GO2
-
-    return ret;
-}
-
 EXPORT int my32_XCloseDisplay(x64emu_t* emu, void* dpy)
 {
     int ret = my->XCloseDisplay(dpy);
-    if(ret)
-        for(int i=0; i<N_DISPLAY; ++i) {
-            // crude free of ressources... not perfect
-            if(my32_Displays_64[i]==dpy) {
-                my32_Displays_64[i] = NULL;
-                return ret;
-            }
-        }
+    if(ret) delDisplay(dpy);
     return ret;
 }
 
@@ -1751,453 +1592,6 @@ EXPORT XID my32_XCreateWindow(x64emu_t* emu, void* d, XID Window, int x, int y,
     return my->XCreateWindow(d, Window, x, y, width, height, border_width, depth, cl, visual, mask, attr?(&attrib):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
-    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);
-    }
-}
-
 EXPORT int my32_XNextEvent(x64emu_t* emu, void* dpy, my_XEvent_32_t* evt)
 {
     my_XEvent_t event = {0};
@@ -2246,6 +1640,14 @@ EXPORT int my32_XWindowEvent(x64emu_t* emu, void* dpy, XID window, long mask, my
     return ret;
 }
 
+EXPORT int my32_XMaskEvent(x64emu_t* emu, void* dpy, long mask, my_XEvent_32_t* evt)
+{
+    my_XEvent_t event = {0};
+    int ret = my->XMaskEvent(dpy, mask, &event);
+    if(ret) convertXEvent(evt, &event);
+    return ret;
+}
+
 EXPORT int my32_XSendEvent(x64emu_t* emu, void* dpy, XID window, int propagate, long mask, my_XEvent_32_t* evt)
 {
     my_XEvent_t event = {0};
@@ -2333,79 +1735,6 @@ EXPORT int my32_XSetWMProtocols(x64emu_t* emu, void* dpy, XID window, XID_32* pr
     return my->XSetWMProtocols(dpy, window, protocol?list:NULL, count);
 }
 
-void convert_XWMints_to_64(void* d, void* s)
-{
-    my_XWMHints_t* dst = d;
-    my_XWMHints_32_t* src = s;
-    long flags = from_long(src->flags);
-    // reverse order
-    if(flags&XWMHint_WindowGroupHint)   dst->window_group = from_ulong(src->window_group);
-    if(flags&XWMHint_IconMaskHint)      dst->icon_mask = from_ulong(src->icon_mask);
-    if(flags&XWMHint_IconPositionHint)  {dst->icon_y = src->icon_y; dst->icon_x = src->icon_x;}
-    if(flags&XWMHint_IconWindowHint)    dst->icon_window = from_ulong(src->icon_window);
-    if(flags&XWMHint_IconPixmapHint)    dst->icon_pixmap = from_ulong(src->icon_pixmap);
-    if(flags&XWMHint_StateHint)         dst->initial_state = src->initial_state;
-    if(flags&XWMHint_InputHint)         dst->input = src->input;
-
-    dst->flags = flags;
-}
-void inplace_enlarge_wmhints(void* hints)
-{
-    if(!hints) return;
-    my_XWMHints_32_t* src = hints;
-    my_XWMHints_t* dst = hints;
-    long flags = from_long(src->flags);
-    // reverse order
-    if(flags&XWMHint_WindowGroupHint)   dst->window_group = from_ulong(src->window_group);
-    if(flags&XWMHint_IconMaskHint)      dst->icon_mask = from_ulong(src->icon_mask);
-    if(flags&XWMHint_IconPositionHint)  {dst->icon_y = src->icon_y; dst->icon_x = src->icon_x;}
-    if(flags&XWMHint_IconWindowHint)    dst->icon_window = from_ulong(src->icon_window);
-    if(flags&XWMHint_IconPixmapHint)    dst->icon_pixmap = from_ulong(src->icon_pixmap);
-    if(flags&XWMHint_StateHint)         dst->initial_state = src->initial_state;
-    if(flags&XWMHint_InputHint)         dst->input = src->input;
-
-    dst->flags = flags;
-}
-void inplace_shrink_wmhints(void* hints)
-{
-    if(!hints) return;
-    my_XWMHints_t* src = hints;
-    my_XWMHints_32_t* dst = hints;
-    long_t flags = to_long(src->flags);
-    // forward order
-    if(flags&XWMHint_InputHint)         dst->input = src->input;
-    if(flags&XWMHint_StateHint)         dst->initial_state = src->initial_state;
-    if(flags&XWMHint_IconPixmapHint)    dst->icon_pixmap = to_ulong(src->icon_pixmap);
-    if(flags&XWMHint_IconWindowHint)    dst->icon_window = to_ulong(src->icon_window);
-    if(flags&XWMHint_IconPositionHint)  {dst->icon_y = src->icon_y; dst->icon_x = src->icon_x;}
-    if(flags&XWMHint_IconMaskHint)      dst->icon_mask = to_ulong(src->icon_mask);
-    if(flags&XWMHint_WindowGroupHint)   dst->window_group = to_ulong(src->window_group);
-
-    dst->flags = flags;
-}
-
-void convert_XSizeHints_to_64(void* d, void *s)
-{
-    //XSizeHints is a long flag and 17*int...
-    long flags = to_long(*(long_t*)s);
-    memcpy(d+8, s+4, 17*4);
-    *(long*)d = flags;
-}
-void inplace_enlarge_wmsizehints(void* hints)
-{
-    //XSizeHints is a long flag and 17*int...
-    long flags = to_long(*(long_t*)hints);
-    memmove(hints+8, hints+4, 17*4);
-    *(long*)hints = flags;
-}
-void inplace_shrink_wmsizehints(void* hints)
-{
-    //XSizeHints is a long flag and 17*int...
-    long_t flags = from_long(*(long*)hints);
-    memmove(hints+4, hints+8, 17*4);
-    *(long_t*)hints = flags;
-}
-
 EXPORT int my32_XSetWMHints(x64emu_t* emu, void* dpy, XID window, void* hints)
 {
     inplace_enlarge_wmhints(hints);
@@ -2414,6 +1743,13 @@ EXPORT int my32_XSetWMHints(x64emu_t* emu, void* dpy, XID window, void* hints)
     return ret;
 }
 
+EXPORT void* my32_XGetWMHints(x64emu_t* emu, void* dpy, XID window)
+{
+    void* ret = my->XGetWMHints(dpy, window);
+    inplace_shrink_wmhints(ret);
+    return ret;
+}
+
 EXPORT int my32_XSetWMNormalHints(x64emu_t* emu, void* dpy, XID window, void* hints)
 {
     inplace_enlarge_wmsizehints(hints);
@@ -2463,35 +1799,6 @@ EXPORT int my32_Xutf8TextListToTextProperty(x64emu_t* emu, void* dpy, ptr_t* lis
     return ret;
 }
 
-void convert_XWindowAttributes_to_32(void* d, void* s)
-{
-    my_XWindowAttributes_t* src = s;
-    my_XWindowAttributes_32_t* dst = d;
-    dst->x = src->x;
-    dst->y = src->y;
-    dst->width = src->width;
-    dst->height = src->height;
-    dst->border_width = src->border_width;
-    dst->depth = src->depth;
-    dst->visual = to_ptrv(src->visual);
-    dst->root = to_ulong(src->root);
-    dst->c_class = src->c_class;
-    dst->bit_gravity = src->bit_gravity;
-    dst->win_gravity = src->win_gravity;
-    dst->backing_store = src->backing_store;
-    dst->backing_planes = to_ulong(src->backing_planes);
-    dst->backing_pixel = to_ulong(src->backing_pixel);
-    dst->save_under = src->save_under;
-    dst->colormap = to_ulong(src->colormap);
-    dst->map_installed = src->map_installed;
-    dst->map_state = src->map_state;
-    dst->all_event_masks = to_long(src->all_event_masks);
-    dst->your_event_mask = to_long(src->your_event_mask);
-    dst->do_not_propagate_mask = to_long(src->do_not_propagate_mask);
-    dst->override_redirect = src->override_redirect;
-    dst->screen = to_ptrv(src->screen);
-}
-
 EXPORT int my32_XGetWindowAttributes(x64emu_t* emu, void* dpy, XID window, my_XWindowAttributes_32_t* attr)
 {
     static my_Screen_32_t screen32 = {0};
@@ -2660,23 +1967,6 @@ EXPORT int my32_XFreeColors(x64emu_t* emu, void* dpy, XID map, ulong_t* pixels,
     return my->XFreeColors(dpy, map, pixels_l, npixels, planes);
 }
 
-void inplace_XModifierKeymap_shrink(void* a)
-{
-    my_XModifierKeymap_32_t *d = a;
-    my_XModifierKeymap_t* s = a;
-
-    d->max_keypermod = s->max_keypermod;
-    d->modifiermap = to_ptrv(s->modifiermap);
-}
-void inplace_XModifierKeymap_enlarge(void* a)
-{
-    my_XModifierKeymap_t *d = a;
-    my_XModifierKeymap_32_t* s = a;
-
-    d->modifiermap = from_ptrv(s->modifiermap);
-    d->max_keypermod = s->max_keypermod;
-}
-
 EXPORT void* my32_XGetModifierMapping(x64emu_t* emu, void* dpy)
 {
     void *ret = my->XGetModifierMapping(dpy);
@@ -2717,49 +2007,6 @@ EXPORT void* my32_XGetIMValues(x64emu_t* emu, void* xim, ptr_t* b)
     return NULL;
 }
 
-void convert_XVisualInfo_to_32(my_XVisualInfo_32_t* dst, my_XVisualInfo_t* src)
-{
-    dst->visual = to_ptrv(src->visual);
-    dst->visualid = to_ulong(src->visualid);
-    dst->screen = src->screen;
-    dst->depth = src->depth;
-    dst->c_class = src->c_class;
-    dst->red_mask = to_ulong(src->red_mask);
-    dst->green_mask = to_ulong(src->green_mask);
-    dst->blue_mask = to_ulong(src->blue_mask);
-    dst->colormap_size = src->colormap_size;
-    dst->bits_per_rgb = src->bits_per_rgb;
-}
-void convert_XVisualInfo_to_64(my_XVisualInfo_t* dst, my_XVisualInfo_32_t* src)
-{
-    dst->bits_per_rgb = src->bits_per_rgb;
-    dst->colormap_size = src->colormap_size;
-    dst->blue_mask = from_ulong(src->blue_mask);
-    dst->green_mask = from_ulong(src->green_mask);
-    dst->red_mask = from_ulong(src->red_mask);
-    dst->c_class = src->c_class;
-    dst->depth = src->depth;
-    dst->screen = src->screen;
-    dst->visualid = from_ulong(src->visualid);
-    dst->visual = from_ptrv(src->visual);
-}
-void inplace_XVisualInfo_shrink(void *a)
-{
-    if(!a) return;
-    my_XVisualInfo_t *src = a;
-    my_XVisualInfo_32_t* dst = a;
-
-    convert_XVisualInfo_to_32(dst, src);
-}
-void inplace_XVisualInfo_enlarge(void *a)
-{
-    if(!a) return;
-    my_XVisualInfo_32_t *src = a;
-    my_XVisualInfo_t* dst = a;
-
-    convert_XVisualInfo_to_64(dst, src);
-}
-
 EXPORT void* my32_XGetVisualInfo(x64emu_t* emu, void* dpy, long mask, my_XVisualInfo_32_t* template, int* n)
 {
     my_XVisualInfo_t template_l = {0};
@@ -2783,7 +2030,11 @@ EXPORT int my32_XQueryColors(x64emu_t* emu, void* dpy, XID map, my_XColor_32_t*
 #define CUSTOM_INIT                 \
     AddAutomaticBridge(lib->w.bridge, vFp_32, *(void**)dlsym(lib->w.lib, "_XLockMutex_fn"), 0, "_XLockMutex_fn"); \
     AddAutomaticBridge(lib->w.bridge, vFp_32, *(void**)dlsym(lib->w.lib, "_XUnlockMutex_fn"), 0, "_XUnlockMutex_fn"); \
-    if(box64_x11threads) my->XInitThreads();
+    if(box64_x11threads) my->XInitThreads();    \
+    my_context->libx11 = lib;
+
+#define CUSTOM_FINI     \
+    my_context->libx11 = NULL;
 #if 0
 #ifdef ANDROID
 #define NEEDED_LIBS "libxcb.so"
diff --git a/src/wrapped32/wrappedlibx11_private.h b/src/wrapped32/wrappedlibx11_private.h
index 3c3b1240..fc0c7a17 100644
--- a/src/wrapped32/wrappedlibx11_private.h
+++ b/src/wrapped32/wrappedlibx11_private.h
@@ -305,13 +305,13 @@ GOM(XESetCloseDisplay, pFEXip)
 //GOM(XESetCreateGC, pFEXip)
 //GOM(XESetError, pFEXip)
 //GOM(XESetErrorString, pFEXip)
-//GOM(XESetEventToWire, pFEXip)
+GOM(XESetEventToWire, pFEXip)
 //GOM(XESetFlushGC, pFEXip)
 //GOM(XESetFreeFont, pFEXip)
 //GOM(XESetFreeGC, pFEXip)
 //GOM(XESetPrintErrorValues, pFEXip)
 //GOM(XESetWireToError, pFEXip)
-//GOM(XESetWireToEvent, pFEXip)
+GOM(XESetWireToEvent, pFEXip)
 //GOM(XESetWireToEventCookie, pFEXip)
 //GOM(XEventMaskOfScreen, lFEbpXLiiiiipippLLLiiiil_)
 GO(_XEventsQueued, iFXi)
@@ -416,7 +416,7 @@ GOM(XGetWindowAttributes, iFEXLp)
 GO(XGetWindowProperty, iFXLLlliLBL_pBL_BL_Bp_)
 GO(XGetWMClientMachine, iFXLbpLiL_)
 //GO(XGetWMColormapWindows, iFXLbbL__p)
-//GO(XGetWMHints, bliiLLiiLL_FXL)
+GOM(XGetWMHints, pFEXL)
 GO(XGetWMIconName, iFXLbpLiL_)
 GO(XGetWMName, iFXLbpLiL_)
 //GO(XGetWMNormalHints, iFpLpp)
@@ -887,7 +887,7 @@ GO(XLowerWindow, iFXL)
 GO(XMapRaised, iFXL)
 GO(XMapSubwindows, iFXL)
 GO(XMapWindow, iFXL)
-//GO(XMaskEvent, iFplp)
+GOM(XMaskEvent, iFEXlp)
 GO(XMatchVisualInfo, iFXiiiBpLiiiLLLii_)
 //GOM(XMaxCmapsOfScreen, iFEbpXLiiiiipippLLLiiiil_)
 GO(XMaxRequestSize, lFX)
@@ -996,7 +996,7 @@ GO(XRemoveFromSaveSet, iFXL)
 GO(XRemoveHost, iFXbiip_)
 GO(XRemoveHosts, iFXbiip_i)
 GO(XReparentWindow, iFXLLii)
-//GO(_XReply, iFppii)
+GO(_XReply, iFXpii)
 GO(XResetScreenSaver, iFX)
 GO(XResizeWindow, iFXLuu)
 GO(XResourceManagerString, pFX)
@@ -1077,7 +1077,7 @@ GOM(XSetIMValues, pFEpV)
 GO(XSetInputFocus, iFXLiL)
 //GOM(XSetIOErrorExitHandler, vFEXpp)
 GOM(XSetIOErrorHandler, pFEp)
-//GO(_XSetLastRequestRead, LFpp)
+GO(_XSetLastRequestRead, LFXp)
 GO(XSetLineAttributes, iFXpuiii)
 GO(XSetLocaleModifiers, pFp)
 GO(XSetModifierMapping, iFXbip_)
diff --git a/src/wrapped32/wrappedlibxext.c b/src/wrapped32/wrappedlibxext.c
index 16d910f3..efd390ba 100644
--- a/src/wrapped32/wrappedlibxext.c
+++ b/src/wrapped32/wrappedlibxext.c
@@ -26,35 +26,17 @@
 
 #define LIBNAME libxext
 
-#include "libtools/my_x11_defs.h"
-#include "libtools/my_x11_defs_32.h"
+#include "libtools/my_x11_conv.h"
 
 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 struct my32_XExtensionHooks {
-    int (*create_gc)(void*, uint32_t, void*);
-    int (*copy_gc)(void*, uint32_t, void*);
-    int (*flush_gc)(void*, uint32_t, void*);
-    int (*free_gc)(void*, uint32_t, void*);
-    int (*create_font)(void*, void*, void*);
-    int (*free_font)(void*, void*, void*);
-    int (*close_display)(void*, void*);
-    int (*wire_to_event)(void*, void*, void*);
-    int (*event_to_wire)(void*, void*, void*);
-    int (*error)(void*, void*, void*, int*);
-    char *(*error_string)(void*, int, void*, void*, int);
-} my32_XExtensionHooks;
-
-
 #include "generated/wrappedlibxexttypes32.h"
 
 #include "wrappercallback32.h"
 
-void* getDisplay(void*);
-
 #define SUPER() \
 GO(0)   \
 GO(1)   \
@@ -96,10 +78,10 @@ static void* reverse_exterrorhandleFct(void* fct)
 }
 // create_gc ...
 #define GO(A)   \
-static uintptr_t my_create_gc_fct_##A = 0;                          \
-static int my_create_gc_##A(void* a, uint32_t b, void* c)           \
-{                                                                   \
-    return RunFunctionFmt(my_create_gc_fct_##A, "pup", a, b, c);    \
+static uintptr_t my_create_gc_fct_##A = 0;                                      \
+static int my_create_gc_##A(void* a, uint32_t b, void* c)                       \
+{                                                                               \
+    return RunFunctionFmt(my_create_gc_fct_##A, "pup", getDisplay(a), b, c);    \
 }
 SUPER()
 #undef GO
@@ -118,10 +100,10 @@ static void* find_create_gc_Fct(void* fct)
 }
 // copy_gc ...
 #define GO(A)   \
-static uintptr_t my_copy_gc_fct_##A = 0;                        \
-static int my_copy_gc_##A(void* a, uint32_t b, void* c)         \
-{                                                               \
-    return RunFunctionFmt(my_copy_gc_fct_##A, "pup", a, b, c);  \
+static uintptr_t my_copy_gc_fct_##A = 0;                                    \
+static int my_copy_gc_##A(void* a, uint32_t b, void* c)                     \
+{                                                                           \
+    return RunFunctionFmt(my_copy_gc_fct_##A, "pup", getDisplay(a), b, c);  \
 }
 SUPER()
 #undef GO
@@ -140,10 +122,10 @@ static void* find_copy_gc_Fct(void* fct)
 }
 // flush_gc ...
 #define GO(A)   \
-static uintptr_t my_flush_gc_fct_##A = 0;                           \
-static int my_flush_gc_##A(void* a, uint32_t b, void* c)            \
-{                                                                   \
-    return RunFunctionFmt(my_flush_gc_fct_##A, "pup", a, b, c);     \
+static uintptr_t my_flush_gc_fct_##A = 0;                                   \
+static int my_flush_gc_##A(void* a, uint32_t b, void* c)                    \
+{                                                                           \
+    return RunFunctionFmt(my_flush_gc_fct_##A, "pup", getDisplay(a), b, c); \
 }
 SUPER()
 #undef GO
@@ -162,10 +144,10 @@ static void* find_flush_gc_Fct(void* fct)
 }
 // free_gc ...
 #define GO(A)   \
-static uintptr_t my_free_gc_fct_##A = 0;                           \
-static int my_free_gc_##A(void* a, uint32_t b, void* c)            \
-{                                                                  \
-    return RunFunctionFmt(my_free_gc_fct_##A, "pup", a, b, c);     \
+static uintptr_t my_free_gc_fct_##A = 0;                                    \
+static int my_free_gc_##A(void* a, uint32_t b, void* c)                     \
+{                                                                           \
+    return RunFunctionFmt(my_free_gc_fct_##A, "pup", getDisplay(a), b, c);  \
 }
 SUPER()
 #undef GO
@@ -184,10 +166,13 @@ static void* find_free_gc_Fct(void* fct)
 }
 // create_font ...
 #define GO(A)   \
-static uintptr_t my_create_font_fct_##A = 0;                            \
-static int my_create_font_##A(void* a, void* b, void* c)                \
-{                                                                       \
-    return RunFunctionFmt(my_create_font_fct_##A, "ppp", a, b, c);      \
+static uintptr_t my_create_font_fct_##A = 0;                                        \
+static int my_create_font_##A(void* a, void* b, void* c)                            \
+{                                                                                   \
+    inplace_XFontStruct_shrink(b);                                                  \
+    int ret = RunFunctionFmt(my_create_font_fct_##A, "ppp", getDisplay(a), b, c);   \
+    inplace_XFontStruct_enlarge(b);                                                 \
+    return ret;                                                                     \
 }
 SUPER()
 #undef GO
@@ -206,10 +191,13 @@ static void* find_create_font_Fct(void* fct)
 }
 // free_font ...
 #define GO(A)   \
-static uintptr_t my_free_font_fct_##A = 0;                            \
-static int my_free_font_##A(void* a, void* b, void* c)                \
-{                                                                     \
-    return RunFunctionFmt(my_free_font_fct_##A, "ppp", a, b, c);      \
+static uintptr_t my_free_font_fct_##A = 0;                                      \
+static int my_free_font_##A(void* a, void* b, void* c)                          \
+{                                                                               \
+    inplace_XFontStruct_shrink(b);                                              \
+    int ret = RunFunctionFmt(my_free_font_fct_##A, "ppp", getDisplay(a), b, c); \
+    inplace_XFontStruct_enlarge(b);                                             \
+    return ret;                                                                 \
 }
 SUPER()
 #undef GO
@@ -228,10 +216,10 @@ static void* find_free_font_Fct(void* fct)
 }
 // close_display ...
 #define GO(A)   \
-static uintptr_t my_close_display_fct_##A = 0;                  \
-static int my_close_display_##A(void* a, void* b)               \
-{                                                               \
-    return RunFunctionFmt(my_close_display_fct_##A, "pp", a, b);\
+static uintptr_t my_close_display_fct_##A = 0;                                  \
+static int my_close_display_##A(void* a, void* b)                               \
+{                                                                               \
+    return RunFunctionFmt(my_close_display_fct_##A, "pp", getDisplay(a), b);    \
 }
 SUPER()
 #undef GO
@@ -250,10 +238,12 @@ static void* find_close_display_Fct(void* fct)
 }
 // 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)              \
-{                                                                       \
-    return RunFunctionFmt(my_wire_to_event_fct_##A, "ppp", a, b, c);    \
+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);                                                           \
 }
 SUPER()
 #undef GO
@@ -272,10 +262,12 @@ static void* find_wire_to_event_Fct(void* 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)              \
-{                                                                       \
-    return RunFunctionFmt(my_event_to_wire_fct_##A, "ppp", a, b, c);    \
+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); \
 }
 SUPER()
 #undef GO
@@ -294,10 +286,10 @@ static void* find_event_to_wire_Fct(void* fct)
 }
 // error ...
 #define GO(A)   \
-static uintptr_t my_error_fct_##A = 0;                              \
-static int my_error_##A(void* a, void* b, void* c, int* d)          \
-{                                                                   \
-    return RunFunctionFmt(my_error_fct_##A, "pppp", a, b, c, d);    \
+static uintptr_t my_error_fct_##A = 0;                                          \
+static int my_error_##A(void* a, void* b, void* c, int* d)                      \
+{                                                                               \
+    return RunFunctionFmt(my_error_fct_##A, "pppp", getDisplay(a), b, c, d);    \
 }
 SUPER()
 #undef GO
@@ -316,10 +308,10 @@ static void* find_error_Fct(void* fct)
 }
 // error_string ...
 #define GO(A)   \
-static uintptr_t my_error_string_fct_##A = 0;                               \
-static int my_error_string_##A(void* a, int b, void* c, void* d, int e)     \
-{                                                                           \
-    return RunFunctionFmt(my_error_string_fct_##A, "pippi", a, b, c, d, e); \
+static uintptr_t my_error_string_fct_##A = 0;                                           \
+static int my_error_string_##A(void* a, int b, void* c, void* d, int e)                 \
+{                                                                                       \
+    return RunFunctionFmt(my_error_string_fct_##A, "pippi", getDisplay(a), b, c, d, e); \
 }
 SUPER()
 #undef GO
@@ -395,48 +387,6 @@ EXPORT void* my32_XSetExtensionErrorHandler(x64emu_t* emu, void* handler)
 //    void *ret = my->XextAddDisplay(extinfo, dpy, extname, &natives, nevents, data);
 //    return ret;
 //}
-void inplace_XdbeVisualInfo_shrink(void* a)
-{
-    if(!a) return;
-    my_XdbeVisualInfo_t *src = a;
-    my_XdbeVisualInfo_32_t* dst = a;
-
-    dst->visual = to_ulong(src->visual);
-    dst->depth = src->depth;
-    dst->perflevel = src->perflevel;
-}
-void inplace_XdbeScreenVisualInfo_shrink(void* a)
-{
-    if(!a) return;
-    my_XdbeScreenVisualInfo_t *src = a;
-    my_XdbeScreenVisualInfo_32_t* dst = a;
-
-    for(int i=0; i<src->count; ++i)
-        inplace_XdbeVisualInfo_shrink(src->visinfo+i);
-    dst->count = src->count;
-    dst->visinfo = to_ptrv(src->visinfo);
-}
-void inplace_XdbeVisualInfo_enlarge(void* a)
-{
-    if(!a) return;
-    my_XdbeVisualInfo_32_t *src = a;
-    my_XdbeVisualInfo_t* dst = a;
-
-    dst->perflevel = src->perflevel;
-    dst->depth = src->depth;
-    dst->visual = from_ulong(src->visual);
-}
-void inplace_XdbeScreenVisualInfo_enlarge(void* a)
-{
-    if(!a) return;
-    my_XdbeScreenVisualInfo_32_t *src = a;
-    my_XdbeScreenVisualInfo_t* dst = a;
-
-    dst->visinfo = from_ptrv(src->visinfo);
-    dst->count = src->count;
-    for(int i=dst->count-1; i>=0; --i)
-        inplace_XdbeVisualInfo_enlarge(dst->visinfo+i);
-}
 
 EXPORT void* my32_XdbeGetVisualInfo(x64emu_t* emu, void* dpy, XID_32* draws, int* num)
 {
@@ -455,6 +405,47 @@ EXPORT void my32_XdbeFreeVisualInfo(x64emu_t* emu, void* infos)
     my->XdbeFreeVisualInfo(infos);
 }
 
+EXPORT void* my32_XextCreateExtension(x64emu_t* emu)
+{
+    return  inplace_XExtensionInfo_shrink(my->XextCreateExtension());
+}
+
+EXPORT void my32_XextDestroyExtension(x64emu_t* emu, void* ext)
+{
+    my->XextDestroyExtension(inplace_XExtensionInfo_enlarge(ext));
+}
+
+EXPORT void* my32_XextAddDisplay(x64emu_t* emu, void* ext, void* dpy, void* name, my_XExtensionHooks_32_t* hooks, int nevents, void* data)
+{
+    my_XExtensionHooks_t hooks_l = {0};
+    if(hooks) {
+        #define GO(A) hooks_l.A = find_##A##_Fct(from_ptrv(hooks->A))
+        GO(create_gc);
+        GO(copy_gc);
+        GO(flush_gc);
+        GO(free_gc);
+        GO(create_font);
+        GO(free_font);
+        GO(close_display);
+        GO(wire_to_event);
+        GO(event_to_wire);
+        GO(error);
+        GO(error_string);
+        #undef GO
+    }
+    inplace_XExtensionInfo_shrink(my->XextAddDisplay(inplace_XExtensionInfo_enlarge(ext), dpy, name, hooks?(&hooks_l):NULL, nevents, data));
+}
+
+EXPORT void* my32_XextFindDisplay(x64emu_t* emu, void* ext, void* dpy)
+{
+    return inplace_XExtensionInfo_shrink(my->XextFindDisplay(inplace_XExtensionInfo_enlarge(ext), dpy));
+}
+
+EXPORT int my32_XextRemoveDisplay(x64emu_t* emu, void* ext, void* dpy)
+{
+    return my->XextRemoveDisplay(inplace_XExtensionInfo_enlarge(ext), dpy);
+}
+
 #if 0
 #ifdef ANDROID
 #define NEEDED_LIBS "libX11.so", "libxcb.so", "libXau.so", "libdl.so", "libXdmcp.so"
diff --git a/src/wrapped32/wrappedlibxext_private.h b/src/wrapped32/wrappedlibxext_private.h
index 1f46c486..ea66930f 100644
--- a/src/wrapped32/wrappedlibxext_private.h
+++ b/src/wrapped32/wrappedlibxext_private.h
@@ -34,12 +34,12 @@ GO(XdbeSwapBuffers, iFXbLC_i)
 //GO(XeviGetVisualInfo, iFXbL_ibbLiiuuuuubL___p)
 GO(XeviQueryExtension, iFX)
 GO(XeviQueryVersion, iFXpp)
-//GOM(XextAddDisplay, pFEbppi_Xpbppppppppppp_ip)
-//GOM(XextCreateExtension, bppi_FEv)
-//GOM(XextDestroyExtension, vFEbppi_)
+GOM(XextAddDisplay, pFEpXppip)
+GOM(XextCreateExtension, pFEv)
+GOM(XextDestroyExtension, vFEp)
 //DATAB(_XExtensionErrorFunction, 4)
-//GOM(XextFindDisplay, pFEbppi_X)
-//GOM(XextRemoveDisplay, iFEbppi_X)
+GOM(XextFindDisplay, pFEpX)
+GOM(XextRemoveDisplay, iFEpX)
 GO(XGEQueryExtension, iFXpp)
 GO(XGEQueryVersion, iFXpp)
 GO(XLbxGetEventBase, iFX)