first testsX11Backend

1 files changed, 1907 insertions, 0 deletions

diff --git a/CrowX/X11/Structs.cs b/CrowX/X11/Structs.cs
new file mode 100644
index 00000000..b2e93d84
--- /dev/null
+++ b/CrowX/X11/Structs.cs
@@ -0,0 +1,1907 @@
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software",, to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+// Copyright (c) 2004 Novell, Inc.
+//
+// Authors:
+//    Peter Bartok    pbartok@novell.com
+//
+
+
+// NOT COMPLETE
+
+using System;
+using System.ComponentModel;
+using System.Collections;
+#if !MINIMAL
+using System.Drawing;
+#endif
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+
+// Disable unused field warnings. This is interop, we don't use everything
+#pragma warning disable 0649
+
+// X11 Version
+namespace X11Sharp
+{
+    using Bool = System.Boolean;
+    using Time = System.IntPtr;
+    using Window = System.IntPtr;
+
+    //
+    // In the structures below, fields of type long are mapped to IntPtr.
+    // This will work on all platforms where sizeof(long)==sizeof(void*), which
+    // is almost all platforms except WIN64.
+    //
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XAnyEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr window;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XKeyEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr window;
+        public IntPtr root;
+        public IntPtr subwindow;
+        public IntPtr time;
+        public int x;
+        public int y;
+        public int x_root;
+        public int y_root;
+        public int state;
+        public int keycode;
+        public bool same_screen;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XButtonEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr window;
+        public IntPtr root;
+        public IntPtr subwindow;
+        public IntPtr time;
+        public int x;
+        public int y;
+        public int x_root;
+        public int y_root;
+        public int state;
+        public int button;
+        public bool same_screen;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XMotionEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr window;
+        public IntPtr root;
+        public IntPtr subwindow;
+        public IntPtr time;
+        public int x;
+        public int y;
+        public int x_root;
+        public int y_root;
+        public int state;
+        public byte is_hint;
+        public bool same_screen;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XCrossingEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr window;
+        public IntPtr root;
+        public IntPtr subwindow;
+        public IntPtr time;
+        public int x;
+        public int y;
+        public int x_root;
+        public int y_root;
+        public NotifyMode mode;
+        public NotifyDetail detail;
+        public bool same_screen;
+        public bool focus;
+        public int state;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XFocusChangeEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr window;
+        public int mode;
+        public NotifyDetail detail;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XKeymapEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr window;
+        public byte key_vector0;
+        public byte key_vector1;
+        public byte key_vector2;
+        public byte key_vector3;
+        public byte key_vector4;
+        public byte key_vector5;
+        public byte key_vector6;
+        public byte key_vector7;
+        public byte key_vector8;
+        public byte key_vector9;
+        public byte key_vector10;
+        public byte key_vector11;
+        public byte key_vector12;
+        public byte key_vector13;
+        public byte key_vector14;
+        public byte key_vector15;
+        public byte key_vector16;
+        public byte key_vector17;
+        public byte key_vector18;
+        public byte key_vector19;
+        public byte key_vector20;
+        public byte key_vector21;
+        public byte key_vector22;
+        public byte key_vector23;
+        public byte key_vector24;
+        public byte key_vector25;
+        public byte key_vector26;
+        public byte key_vector27;
+        public byte key_vector28;
+        public byte key_vector29;
+        public byte key_vector30;
+        public byte key_vector31;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XExposeEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr window;
+        public int x;
+        public int y;
+        public int width;
+        public int height;
+        public int count;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XGraphicsExposeEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr drawable;
+        public int x;
+        public int y;
+        public int width;
+        public int height;
+        public int count;
+        public int major_code;
+        public int minor_code;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XNoExposeEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr drawable;
+        public int major_code;
+        public int minor_code;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XVisibilityEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr window;
+        public int state;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XCreateWindowEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr parent;
+        public IntPtr window;
+        public int x;
+        public int y;
+        public int width;
+        public int height;
+        public int border_width;
+        public bool override_redirect;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XDestroyWindowEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr xevent;
+        public IntPtr window;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XUnmapEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr xevent;
+        public IntPtr window;
+        public bool from_configure;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XMapEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr xevent;
+        public IntPtr window;
+        public bool override_redirect;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XMapRequestEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr parent;
+        public IntPtr window;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XReparentEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr xevent;
+        public IntPtr window;
+        public IntPtr parent;
+        public int x;
+        public int y;
+        public bool override_redirect;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XConfigureEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr xevent;
+        public IntPtr window;
+        public int x;
+        public int y;
+        public int width;
+        public int height;
+        public int border_width;
+        public IntPtr above;
+        public bool override_redirect;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XGravityEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr xevent;
+        public IntPtr window;
+        public int x;
+        public int y;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XResizeRequestEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr window;
+        public int width;
+        public int height;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XConfigureRequestEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr parent;
+        public IntPtr window;
+        public int x;
+        public int y;
+        public int width;
+        public int height;
+        public int border_width;
+        public IntPtr above;
+        public int detail;
+        public IntPtr value_mask;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XCirculateEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr xevent;
+        public IntPtr window;
+        public int place;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XCirculateRequestEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr parent;
+        public IntPtr window;
+        public int place;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XPropertyEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr window;
+        public IntPtr atom;
+        public IntPtr time;
+        public int state;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XSelectionClearEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr window;
+        public IntPtr selection;
+        public IntPtr time;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XSelectionRequestEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr owner;
+        public IntPtr requestor;
+        public IntPtr selection;
+        public IntPtr target;
+        public IntPtr property;
+        public IntPtr time;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XSelectionEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr requestor;
+        public IntPtr selection;
+        public IntPtr target;
+        public IntPtr property;
+        public IntPtr time;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XColormapEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr window;
+        public IntPtr colormap;
+        public bool c_new;
+        public int state;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XClientMessageEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr window;
+        public IntPtr message_type;
+        public int format;
+        public IntPtr ptr1;
+        public IntPtr ptr2;
+        public IntPtr ptr3;
+        public IntPtr ptr4;
+        public IntPtr ptr5;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XMappingEvent
+    {
+        public XEventName type;
+        public IntPtr serial;
+        public bool send_event;
+        public IntPtr display;
+        public IntPtr window;
+        public int request;
+        public int first_keycode;
+        public int count;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XErrorEvent
+    {
+        public XEventName type;
+        public IntPtr display;
+        public IntPtr resourceid;
+        public IntPtr serial;
+        public byte error_code;
+        public XRequest request_code;
+        public byte minor_code;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XEventPad
+    {
+        public IntPtr pad0;
+        public IntPtr pad1;
+        public IntPtr pad2;
+        public IntPtr pad3;
+        public IntPtr pad4;
+        public IntPtr pad5;
+        public IntPtr pad6;
+        public IntPtr pad7;
+        public IntPtr pad8;
+        public IntPtr pad9;
+        public IntPtr pad10;
+        public IntPtr pad11;
+        public IntPtr pad12;
+        public IntPtr pad13;
+        public IntPtr pad14;
+        public IntPtr pad15;
+        public IntPtr pad16;
+        public IntPtr pad17;
+        public IntPtr pad18;
+        public IntPtr pad19;
+        public IntPtr pad20;
+        public IntPtr pad21;
+        public IntPtr pad22;
+        public IntPtr pad23;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XGenericEvent
+    {
+        public int type;         // of event. Always GenericEvent
+        public IntPtr serial;       // # of last request processed
+        public bool send_event;   // true if from SendEvent request
+        public IntPtr display;     // Display the event was read from
+        public int extension;    // major opcode of extension that caused the event
+        public int evtype;       // actual event type.
+    }
+
+    internal struct XGenericEventCookie
+    {
+        public int type;         // of event. Always GenericEvent
+        public IntPtr serial;       // # of last request processed
+        public bool send_event;   // true if from SendEvent request
+        public IntPtr display;     // Display the event was read from
+        public int extension;    // major opcode of extension that caused the event
+        public int evtype;       // actual event type.
+        public uint cookie;       // unique event cookie
+        public IntPtr data;        // actual event data
+    }
+
+    [StructLayout(LayoutKind.Explicit)]
+    internal struct XEvent
+    {
+        [FieldOffset(0)]
+        public XEventName type;
+        [FieldOffset(0)]
+        public XAnyEvent AnyEvent;
+        [FieldOffset(0)]
+        public XKeyEvent KeyEvent;
+        [FieldOffset(0)]
+        public XButtonEvent ButtonEvent;
+        [FieldOffset(0)]
+        public XMotionEvent MotionEvent;
+        [FieldOffset(0)]
+        public XCrossingEvent CrossingEvent;
+        [FieldOffset(0)]
+        public XFocusChangeEvent FocusChangeEvent;
+        [FieldOffset(0)]
+        public XExposeEvent ExposeEvent;
+        [FieldOffset(0)]
+        public XGraphicsExposeEvent GraphicsExposeEvent;
+        [FieldOffset(0)]
+        public XNoExposeEvent NoExposeEvent;
+        [FieldOffset(0)]
+        public XVisibilityEvent VisibilityEvent;
+        [FieldOffset(0)]
+        public XCreateWindowEvent CreateWindowEvent;
+        [FieldOffset(0)]
+        public XDestroyWindowEvent DestroyWindowEvent;
+        [FieldOffset(0)]
+        public XUnmapEvent UnmapEvent;
+        [FieldOffset(0)]
+        public XMapEvent MapEvent;
+        [FieldOffset(0)]
+        public XMapRequestEvent MapRequestEvent;
+        [FieldOffset(0)]
+        public XReparentEvent ReparentEvent;
+        [FieldOffset(0)]
+        public XConfigureEvent ConfigureEvent;
+        [FieldOffset(0)]
+        public XGravityEvent GravityEvent;
+        [FieldOffset(0)]
+        public XResizeRequestEvent ResizeRequestEvent;
+        [FieldOffset(0)]
+        public XConfigureRequestEvent ConfigureRequestEvent;
+        [FieldOffset(0)]
+        public XCirculateEvent CirculateEvent;
+        [FieldOffset(0)]
+        public XCirculateRequestEvent CirculateRequestEvent;
+        [FieldOffset(0)]
+        public XPropertyEvent PropertyEvent;
+        [FieldOffset(0)]
+        public XSelectionClearEvent SelectionClearEvent;
+        [FieldOffset(0)]
+        public XSelectionRequestEvent SelectionRequestEvent;
+        [FieldOffset(0)]
+        public XSelectionEvent SelectionEvent;
+        [FieldOffset(0)]
+        public XColormapEvent ColormapEvent;
+        [FieldOffset(0)]
+        public XClientMessageEvent ClientMessageEvent;
+        [FieldOffset(0)]
+        public XMappingEvent MappingEvent;
+        [FieldOffset(0)]
+        public XErrorEvent ErrorEvent;
+        [FieldOffset(0)]
+        public XKeymapEvent KeymapEvent;
+        [FieldOffset(0)]
+        public XGenericEvent GenericEvent;
+        [FieldOffset(0)]
+        public XGenericEventCookie GenericEventCookie;
+
+        //[MarshalAs(System.Runtime.InteropServices.UnmanagedType.ByValArray, SizeConst=24)]
+        //[ FieldOffset(0) ] public int[] pad;
+        [FieldOffset(0)]
+        public XEventPad Pad;
+        public override string ToString()
+        {
+            switch (type)
+            {
+                case XEventName.PropertyNotify:
+                    return ToString(PropertyEvent);
+                case XEventName.ResizeRequest:
+                    return ToString(ResizeRequestEvent);
+                case XEventName.ConfigureNotify:
+                    return ToString(ConfigureEvent);
+                default:
+                    return type.ToString();
+            }
+        }
+
+        public static string ToString(object ev)
+        {
+            string result = string.Empty;
+            Type type = ev.GetType();
+            System.Reflection.FieldInfo[] fields = type.GetFields(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Instance);
+            for (int i = 0; i < fields.Length; i++)
+            {
+                if (result != string.Empty)
+                {
+                    result += ", ";
+                }
+                object value = fields[i].GetValue(ev);
+                result += fields[i].Name + "=" + (value == null ? "<null>" : value.ToString());
+            }
+            return type.Name + " (" + result + ")";
+        }
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XSetWindowAttributes
+    {
+        public IntPtr background_pixmap;
+        public IntPtr background_pixel;
+        public IntPtr border_pixmap;
+        public IntPtr border_pixel;
+        public Gravity bit_gravity;
+        public Gravity win_gravity;
+        public int backing_store;
+        public IntPtr backing_planes;
+        public IntPtr backing_pixel;
+        public bool save_under;
+        public IntPtr event_mask;
+        public IntPtr do_not_propagate_mask;
+        public bool override_redirect;
+        public IntPtr colormap;
+        public IntPtr cursor;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XWindowAttributes
+    {
+        public int x;
+        public int y;
+        public int width;
+        public int height;
+        public int border_width;
+        public int depth;
+        public IntPtr visual;
+        public IntPtr root;
+        public int c_class;
+        public Gravity bit_gravity;
+        public Gravity win_gravity;
+        public int backing_store;
+        public IntPtr backing_planes;
+        public IntPtr backing_pixel;
+        public bool save_under;
+        public IntPtr colormap;
+        public bool map_installed;
+        public MapState map_state;
+        public IntPtr all_event_masks;
+        public IntPtr your_event_mask;
+        public IntPtr do_not_propagate_mask;
+        public bool override_direct;
+        public IntPtr screen;
+
+        public override string ToString()
+        {
+            return XEvent.ToString(this);
+        }
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XTextProperty
+    {
+        public string value;
+        public IntPtr encoding;
+        public int format;
+        public IntPtr nitems;
+    }
+
+    internal struct XClassHint
+    {
+        [MarshalAs(UnmanagedType.LPStr)]
+        public string Name;
+        [MarshalAs(UnmanagedType.LPStr)]
+        public string Class;
+    }
+
+    internal enum XWindowClass
+    {
+        InputOutput = 1,
+        InputOnly = 2
+    }
+
+    internal enum XEventName
+    {
+        KeyPress = 2,
+        KeyRelease = 3,
+        ButtonPress = 4,
+        ButtonRelease = 5,
+        MotionNotify = 6,
+        EnterNotify = 7,
+        LeaveNotify = 8,
+        FocusIn = 9,
+        FocusOut = 10,
+        KeymapNotify = 11,
+        Expose = 12,
+        GraphicsExpose = 13,
+        NoExpose = 14,
+        VisibilityNotify = 15,
+        CreateNotify = 16,
+        DestroyNotify = 17,
+        UnmapNotify = 18,
+        MapNotify = 19,
+        MapRequest = 20,
+        ReparentNotify = 21,
+        ConfigureNotify = 22,
+        ConfigureRequest = 23,
+        GravityNotify = 24,
+        ResizeRequest = 25,
+        CirculateNotify = 26,
+        CirculateRequest = 27,
+        PropertyNotify = 28,
+        SelectionClear = 29,
+        SelectionRequest = 30,
+        SelectionNotify = 31,
+        ColormapNotify = 32,
+        ClientMessage = 33,
+        MappingNotify = 34,
+        GenericEvent = 35,
+
+        LASTEvent
+    }
+
+    [Flags]
+    internal enum SetWindowValuemask
+    {
+        Nothing = 0,
+        BackPixmap = 1,
+        BackPixel = 2,
+        BorderPixmap = 4,
+        BorderPixel = 8,
+        BitGravity = 16,
+        WinGravity = 32,
+        BackingStore = 64,
+        BackingPlanes = 128,
+        BackingPixel = 256,
+        OverrideRedirect = 512,
+        SaveUnder = 1024,
+        EventMask = 2048,
+        DontPropagate = 4096,
+        ColorMap = 8192,
+        Cursor = 16384
+    }
+
+    internal enum CreateWindowArgs
+    {
+        CopyFromParent = 0,
+        ParentRelative = 1,
+        InputOutput = 1,
+        InputOnly = 2
+    }
+
+    internal enum Gravity
+    {
+        ForgetGravity = 0,
+        NorthWestGravity = 1,
+        NorthGravity = 2,
+        NorthEastGravity = 3,
+        WestGravity = 4,
+        CenterGravity = 5,
+        EastGravity = 6,
+        SouthWestGravity = 7,
+        SouthGravity = 8,
+        SouthEastGravity = 9,
+        StaticGravity = 10
+    }
+
+    internal enum XKeySym : uint
+    {
+        XK_BackSpace = 0xFF08,
+        XK_Tab = 0xFF09,
+        XK_Clear = 0xFF0B,
+        XK_Return = 0xFF0D,
+        XK_Home = 0xFF50,
+        XK_Left = 0xFF51,
+        XK_Up = 0xFF52,
+        XK_Right = 0xFF53,
+        XK_Down = 0xFF54,
+        XK_Page_Up = 0xFF55,
+        XK_Page_Down = 0xFF56,
+        XK_End = 0xFF57,
+        XK_Begin = 0xFF58,
+        XK_Menu = 0xFF67,
+        XK_Shift_L = 0xFFE1,
+        XK_Shift_R = 0xFFE2,
+        XK_Control_L = 0xFFE3,
+        XK_Control_R = 0xFFE4,
+        XK_Caps_Lock = 0xFFE5,
+        XK_Shift_Lock = 0xFFE6,
+        XK_Meta_L = 0xFFE7,
+        XK_Meta_R = 0xFFE8,
+        XK_Alt_L = 0xFFE9,
+        XK_Alt_R = 0xFFEA,
+        XK_Super_L = 0xFFEB,
+        XK_Super_R = 0xFFEC,
+        XK_Hyper_L = 0xFFED,
+        XK_Hyper_R = 0xFFEE,
+    }
+
+#pragma warning disable 1591
+
+    [Flags]
+    public enum EventMask
+    {
+        NoEventMask = 0,
+        KeyPressMask = 1 << 0,
+        KeyReleaseMask = 1 << 1,
+        ButtonPressMask = 1 << 2,
+        ButtonReleaseMask = 1 << 3,
+        EnterWindowMask = 1 << 4,
+        LeaveWindowMask = 1 << 5,
+        PointerMotionMask = 1 << 6,
+        PointerMotionHintMask = 1 << 7,
+        Button1MotionMask = 1 << 8,
+        Button2MotionMask = 1 << 9,
+        Button3MotionMask = 1 << 10,
+        Button4MotionMask = 1 << 11,
+        Button5MotionMask = 1 << 12,
+        ButtonMotionMask = 1 << 13,
+        KeymapStateMask = 1 << 14,
+        ExposureMask = 1 << 15,
+        VisibilityChangeMask = 1 << 16,
+        StructureNotifyMask = 1 << 17,
+        ResizeRedirectMask = 1 << 18,
+        SubstructureNotifyMask = 1 << 19,
+        SubstructureRedirectMask = 1 << 20,
+        FocusChangeMask = 1 << 21,
+        PropertyChangeMask = 1 << 22,
+        ColormapChangeMask = 1 << 23,
+        OwnerGrabButtonMask = 1 << 24
+    }
+
+#pragma warning restore 1591
+
+    internal enum GrabMode
+    {
+        GrabModeSync = 0,
+        GrabModeAsync = 1
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XStandardColormap
+    {
+        public IntPtr colormap;
+        public IntPtr red_max;
+        public IntPtr red_mult;
+        public IntPtr green_max;
+        public IntPtr green_mult;
+        public IntPtr blue_max;
+        public IntPtr blue_mult;
+        public IntPtr base_pixel;
+        public IntPtr visualid;
+        public IntPtr killid;
+    }
+
+    [StructLayout(LayoutKind.Sequential, Pack = 2)]
+    internal struct XColor
+    {
+        public IntPtr pixel;
+        public ushort red;
+        public ushort green;
+        public ushort blue;
+        public byte flags;
+        public byte pad;
+    }
+
+    internal enum AtomName
+    {
+        AnyPropertyType = 0,
+        XA_PRIMARY = 1,
+        XA_SECONDARY = 2,
+        XA_ARC = 3,
+        XA_ATOM = 4,
+        XA_BITMAP = 5,
+        XA_CARDINAL = 6,
+        XA_COLORMAP = 7,
+        XA_CURSOR = 8,
+        XA_CUT_BUFFER0 = 9,
+        XA_CUT_BUFFER1 = 10,
+        XA_CUT_BUFFER2 = 11,
+        XA_CUT_BUFFER3 = 12,
+        XA_CUT_BUFFER4 = 13,
+        XA_CUT_BUFFER5 = 14,
+        XA_CUT_BUFFER6 = 15,
+        XA_CUT_BUFFER7 = 16,
+        XA_DRAWABLE = 17,
+        XA_FONT = 18,
+        XA_INTEGER = 19,
+        XA_PIXMAP = 20,
+        XA_POINT = 21,
+        XA_RECTANGLE = 22,
+        XA_RESOURCE_MANAGER = 23,
+        XA_RGB_COLOR_MAP = 24,
+        XA_RGB_BEST_MAP = 25,
+        XA_RGB_BLUE_MAP = 26,
+        XA_RGB_DEFAULT_MAP = 27,
+        XA_RGB_GRAY_MAP = 28,
+        XA_RGB_GREEN_MAP = 29,
+        XA_RGB_RED_MAP = 30,
+        XA_STRING = 31,
+        XA_VISUALID = 32,
+        XA_WINDOW = 33,
+        XA_WM_COMMAND = 34,
+        XA_WM_HINTS = 35,
+        XA_WM_CLIENT_MACHINE = 36,
+        XA_WM_ICON_NAME = 37,
+        XA_WM_ICON_SIZE = 38,
+        XA_WM_NAME = 39,
+        XA_WM_NORMAL_HINTS = 40,
+        XA_WM_SIZE_HINTS = 41,
+        XA_WM_ZOOM_HINTS = 42,
+        XA_MIN_SPACE = 43,
+        XA_NORM_SPACE = 44,
+        XA_MAX_SPACE = 45,
+        XA_END_SPACE = 46,
+        XA_SUPERSCRIPT_X = 47,
+        XA_SUPERSCRIPT_Y = 48,
+        XA_SUBSCRIPT_X = 49,
+        XA_SUBSCRIPT_Y = 50,
+        XA_UNDERLINE_POSITION = 51,
+        XA_UNDERLINE_THICKNESS = 52,
+        XA_STRIKEOUT_ASCENT = 53,
+        XA_STRIKEOUT_DESCENT = 54,
+        XA_ITALIC_ANGLE = 55,
+        XA_X_HEIGHT = 56,
+        XA_QUAD_WIDTH = 57,
+        XA_WEIGHT = 58,
+        XA_POINT_SIZE = 59,
+        XA_RESOLUTION = 60,
+        XA_COPYRIGHT = 61,
+        XA_NOTICE = 62,
+        XA_FONT_NAME = 63,
+        XA_FAMILY_NAME = 64,
+        XA_FULL_NAME = 65,
+        XA_CAP_HEIGHT = 66,
+        XA_WM_CLASS = 67,
+        XA_WM_TRANSIENT_FOR = 68,
+
+        XA_LAST_PREDEFINED = 68
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XScreen
+    {
+        public IntPtr ext_data;
+        public IntPtr display;
+        public IntPtr root;
+        public int width;
+        public int height;
+        public int mwidth;
+        public int mheight;
+        public int ndepths;
+        public IntPtr depths;
+        public int root_depth;
+        public IntPtr root_visual;
+        public IntPtr default_gc;
+        public IntPtr cmap;
+        public IntPtr white_pixel;
+        public IntPtr black_pixel;
+        public int max_maps;
+        public int min_maps;
+        public int backing_store;
+        public bool save_unders;
+        public IntPtr root_input_mask;
+    }
+
+    [Flags]
+    internal enum ChangeWindowAttributes
+    {
+        X = 1 << 0,
+        Y = 1 << 1,
+        Width = 1 << 2,
+        Height = 1 << 3,
+        BorderWidth = 1 << 4,
+        Sibling = 1 << 5,
+        StackMode = 1 << 6,
+
+        //BackPixmap    (1L<<0)
+        //BackPixel    (1L<<1)
+        //SaveUnder    (1L<<10)
+        //EventMask    (1L<<11)
+        //DontPropagate    (1L<<12)
+        //Colormap    (1L<<13)
+        //Cursor    (1L<<14)
+        //BorderPixmap    (1L<<2)
+        //BorderPixel    (1L<<3)
+        //BitGravity    (1L<<4)
+        //WinGravity    (1L<<5)
+        //BackingStore    (1L<<6)
+        //BackingPlanes    (1L<<7)
+        //BackingPixel    (1L<<8)
+        OverrideRedirect = 1<<9,
+    }
+
+    internal enum StackMode
+    {
+        Above = 0,
+        Below = 1,
+        TopIf = 2,
+        BottomIf = 3,
+        Opposite = 4
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XWindowChanges
+    {
+        public int x;
+        public int y;
+        public int width;
+        public int height;
+        public int border_width;
+        public IntPtr sibling;
+        public StackMode stack_mode;
+    }
+
+    [Flags]
+    internal enum ColorFlags
+    {
+        DoRed = 1 << 0,
+        DoGreen = 1 << 1,
+        DoBlue = 1 << 2
+    }
+
+    internal enum NotifyMode
+    {
+        NotifyNormal = 0,
+        NotifyGrab = 1,
+        NotifyUngrab = 2
+    }
+
+    internal enum NotifyDetail
+    {
+        NotifyAncestor = 0,
+        NotifyVirtual = 1,
+        NotifyInferior = 2,
+        NotifyNonlinear = 3,
+        NotifyNonlinearVirtual = 4,
+        NotifyPointer = 5,
+        NotifyPointerRoot = 6,
+        NotifyDetailNone = 7
+    }
+
+    [Flags]
+    internal enum KeyMasks
+    {
+        ShiftMask = (1 << 0),
+        LockMask = (1 << 1),
+        ControlMask = (1 << 2),
+        Mod1Mask = (1 << 3),
+        Mod2Mask = (1 << 4),
+        Mod3Mask = (1 << 5),
+        Mod4Mask = (1 << 6),
+        Mod5Mask = (1 << 7),
+
+        ModMasks = Mod1Mask | Mod2Mask | Mod3Mask | Mod4Mask | Mod5Mask
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XModifierKeymap
+    {
+        public int max_keypermod;
+        public IntPtr modifiermap;
+    }
+
+    internal enum PropertyMode
+    {
+        Replace = 0,
+        Prepend = 1,
+        Append = 2
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XKeyBoardState
+    {
+        public int key_click_percent;
+        public int bell_percent;
+        public uint bell_pitch, bell_duration;
+        public IntPtr led_mask;
+        public int global_auto_repeat;
+        public AutoRepeats auto_repeats;
+
+        [StructLayout(LayoutKind.Explicit)]
+        internal struct AutoRepeats
+        {
+            [FieldOffset(0)]
+            public byte first;
+
+            [FieldOffset(31)]
+            public byte last;
+        }
+    }
+
+    [Flags]
+    internal enum GCFunction
+    {
+        GCFunction = 1 << 0,
+        GCPlaneMask = 1 << 1,
+        GCForeground = 1 << 2,
+        GCBackground = 1 << 3,
+        GCLineWidth = 1 << 4,
+        GCLineStyle = 1 << 5,
+        GCCapStyle = 1 << 6,
+        GCJoinStyle = 1 << 7,
+        GCFillStyle = 1 << 8,
+        GCFillRule = 1 << 9,
+        GCTile = 1 << 10,
+        GCStipple = 1 << 11,
+        GCTileStipXOrigin = 1 << 12,
+        GCTileStipYOrigin = 1 << 13,
+        GCFont = 1 << 14,
+        GCSubwindowMode = 1 << 15,
+        GCGraphicsExposures = 1 << 16,
+        GCClipXOrigin = 1 << 17,
+        GCClipYOrigin = 1 << 18,
+        GCClipMask = 1 << 19,
+        GCDashOffset = 1 << 20,
+        GCDashList = 1 << 21,
+        GCArcMode = 1 << 22
+    }
+
+    internal enum GCJoinStyle
+    {
+        JoinMiter = 0,
+        JoinRound = 1,
+        JoinBevel = 2
+    }
+
+    internal enum GCLineStyle
+    {
+        LineSolid = 0,
+        LineOnOffDash = 1,
+        LineDoubleDash = 2
+    }
+
+    internal enum GCCapStyle
+    {
+        CapNotLast = 0,
+        CapButt = 1,
+        CapRound = 2,
+        CapProjecting = 3
+    }
+
+    internal enum GCFillStyle
+    {
+        FillSolid = 0,
+        FillTiled = 1,
+        FillStippled = 2,
+        FillOpaqueStppled = 3
+    }
+
+    internal enum GCFillRule
+    {
+        EvenOddRule = 0,
+        WindingRule = 1
+    }
+
+    internal enum GCArcMode
+    {
+        ArcChord = 0,
+        ArcPieSlice = 1
+    }
+
+    internal enum GCSubwindowMode
+    {
+        ClipByChildren = 0,
+        IncludeInferiors = 1
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XGCValues
+    {
+        public GXFunction function;
+        public IntPtr plane_mask;
+        public IntPtr foreground;
+        public IntPtr background;
+        public int line_width;
+        public GCLineStyle line_style;
+        public GCCapStyle cap_style;
+        public GCJoinStyle join_style;
+        public GCFillStyle fill_style;
+        public GCFillRule fill_rule;
+        public GCArcMode arc_mode;
+        public IntPtr tile;
+        public IntPtr stipple;
+        public int ts_x_origin;
+        public int ts_y_origin;
+        public IntPtr font;
+        public GCSubwindowMode subwindow_mode;
+        public bool graphics_exposures;
+        public int clip_x_origin;
+        public int clib_y_origin;
+        public IntPtr clip_mask;
+        public int dash_offset;
+        public byte dashes;
+    }
+
+    internal enum GXFunction
+    {
+        GXclear = 0x0,        /* 0 */
+        GXand = 0x1,        /* src AND dst */
+        GXandReverse = 0x2,        /* src AND NOT dst */
+        GXcopy = 0x3,        /* src */
+        GXandInverted = 0x4,        /* NOT src AND dst */
+        GXnoop = 0x5,        /* dst */
+        GXxor = 0x6,        /* src XOR dst */
+        GXor = 0x7,        /* src OR dst */
+        GXnor = 0x8,        /* NOT src AND NOT dst */
+        GXequiv = 0x9,        /* NOT src XOR dst */
+        GXinvert = 0xa,        /* NOT dst */
+        GXorReverse = 0xb,        /* src OR NOT dst */
+        GXcopyInverted = 0xc,        /* NOT src */
+        GXorInverted = 0xd,        /* NOT src OR dst */
+        GXnand = 0xe,        /* NOT src OR NOT dst */
+        GXset = 0xf        /* 1 */
+    }
+
+    internal enum NetWindowManagerState
+    {
+        Remove = 0,
+        Add = 1,
+        Toggle = 2
+    }
+
+    internal enum RevertTo
+    {
+        None = 0,
+        PointerRoot = 1,
+        Parent = 2
+    }
+
+    internal enum MapState
+    {
+        IsUnmapped = 0,
+        IsUnviewable = 1,
+        IsViewable = 2
+    }
+
+    internal enum CursorFontShape
+    {
+        XC_X_cursor = 0,
+        XC_arrow = 2,
+        XC_based_arrow_down = 4,
+        XC_based_arrow_up = 6,
+        XC_boat = 8,
+        XC_bogosity = 10,
+        XC_bottom_left_corner = 12,
+        XC_bottom_right_corner = 14,
+        XC_bottom_side = 16,
+        XC_bottom_tee = 18,
+        XC_box_spiral = 20,
+        XC_center_ptr = 22,
+
+        XC_circle = 24,
+        XC_clock = 26,
+        XC_coffee_mug = 28,
+        XC_cross = 30,
+        XC_cross_reverse = 32,
+        XC_crosshair = 34,
+        XC_diamond_cross = 36,
+        XC_dot = 38,
+        XC_dotbox = 40,
+        XC_double_arrow = 42,
+        XC_draft_large = 44,
+        XC_draft_small = 46,
+
+        XC_draped_box = 48,
+        XC_exchange = 50,
+        XC_fleur = 52,
+        XC_gobbler = 54,
+        XC_gumby = 56,
+        XC_hand1 = 58,
+        XC_hand2 = 60,
+        XC_heart = 62,
+        XC_icon = 64,
+        XC_iron_cross = 66,
+        XC_left_ptr = 68,
+        XC_left_side = 70,
+
+        XC_left_tee = 72,
+        XC_left_button = 74,
+        XC_ll_angle = 76,
+        XC_lr_angle = 78,
+        XC_man = 80,
+        XC_middlebutton = 82,
+        XC_mouse = 84,
+        XC_pencil = 86,
+        XC_pirate = 88,
+        XC_plus = 90,
+        XC_question_arrow = 92,
+        XC_right_ptr = 94,
+
+        XC_right_side = 96,
+        XC_right_tee = 98,
+        XC_rightbutton = 100,
+        XC_rtl_logo = 102,
+        XC_sailboat = 104,
+        XC_sb_down_arrow = 106,
+        XC_sb_h_double_arrow = 108,
+        XC_sb_left_arrow = 110,
+        XC_sb_right_arrow = 112,
+        XC_sb_up_arrow = 114,
+        XC_sb_v_double_arrow = 116,
+        XC_sb_shuttle = 118,
+
+        XC_sizing = 120,
+        XC_spider = 122,
+        XC_spraycan = 124,
+        XC_star = 126,
+        XC_target = 128,
+        XC_tcross = 130,
+        XC_top_left_arrow = 132,
+        XC_top_left_corner = 134,
+        XC_top_right_corner = 136,
+        XC_top_side = 138,
+        XC_top_tee = 140,
+        XC_trek = 142,
+
+        XC_ul_angle = 144,
+        XC_umbrella = 146,
+        XC_ur_angle = 148,
+        XC_watch = 150,
+        XC_xterm = 152,
+        XC_num_glyphs = 154
+    }
+
+    internal enum SystrayRequest
+    {
+        SYSTEM_TRAY_REQUEST_DOCK = 0,
+        SYSTEM_TRAY_BEGIN_MESSAGE = 1,
+        SYSTEM_TRAY_CANCEL_MESSAGE = 2
+    }
+
+    [Flags]
+    internal enum XSizeHintsFlags
+    {
+        USPosition = (1 << 0),
+        USSize = (1 << 1),
+        PPosition = (1 << 2),
+        PSize = (1 << 3),
+        PMinSize = (1 << 4),
+        PMaxSize = (1 << 5),
+        PResizeInc = (1 << 6),
+        PAspect = (1 << 7),
+        PAllHints = (PPosition | PSize | PMinSize | PMaxSize | PResizeInc | PAspect),
+        PBaseSize = (1 << 8),
+        PWinGravity = (1 << 9),
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XSizeHints
+    {
+        public IntPtr flags;
+        public int x;
+        public int y;
+        public int width;
+        public int height;
+        public int min_width;
+        public int min_height;
+        public int max_width;
+        public int max_height;
+        public int width_inc;
+        public int height_inc;
+        public int min_aspect_x;
+        public int min_aspect_y;
+        public int max_aspect_x;
+        public int max_aspect_y;
+        public int base_width;
+        public int base_height;
+        public int win_gravity;
+    }
+
+    [Flags]
+    internal enum XWMHintsFlags
+    {
+        InputHint = (1 << 0),
+        StateHint = (1 << 1),
+        IconPixmapHint = (1 << 2),
+        IconWindowHint = (1 << 3),
+        IconPositionHint = (1 << 4),
+        IconMaskHint = (1 << 5),
+        WindowGroupHint = (1 << 6),
+        AllHints = (InputHint | StateHint | IconPixmapHint | IconWindowHint | IconPositionHint | IconMaskHint | WindowGroupHint)
+    }
+
+    internal enum XInitialState
+    {
+        DontCareState = 0,
+        NormalState = 1,
+        ZoomState = 2,
+        IconicState = 3,
+        InactiveState = 4
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XWMHints
+    {
+        public IntPtr flags;
+        public bool input;
+        public XInitialState initial_state;
+        public IntPtr icon_pixmap;
+        public IntPtr icon_window;
+        public int icon_x;
+        public int icon_y;
+        public IntPtr icon_mask;
+        public IntPtr window_group;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct XIconSize
+    {
+        public int min_width;
+        public int min_height;
+        public int max_width;
+        public int max_height;
+        public int width_inc;
+        public int height_inc;
+    }
+
+    internal delegate int XErrorHandler(IntPtr DisplayHandle, ref XErrorEvent error_event);
+
+    internal enum XRequest : byte
+    {
+        X_CreateWindow = 1,
+        X_ChangeWindowAttributes = 2,
+        X_GetWindowAttributes = 3,
+        X_DestroyWindow = 4,
+        X_DestroySubwindows = 5,
+        X_ChangeSaveSet = 6,
+        X_ReparentWindow = 7,
+        X_MapWindow = 8,
+        X_MapSubwindows = 9,
+        X_UnmapWindow = 10,
+        X_UnmapSubwindows = 11,
+        X_ConfigureWindow = 12,
+        X_CirculateWindow = 13,
+        X_GetGeometry = 14,
+        X_QueryTree = 15,
+        X_InternAtom = 16,
+        X_GetAtomName = 17,
+        X_ChangeProperty = 18,
+        X_DeleteProperty = 19,
+        X_GetProperty = 20,
+        X_ListProperties = 21,
+        X_SetSelectionOwner = 22,
+        X_GetSelectionOwner = 23,
+        X_ConvertSelection = 24,
+        X_SendEvent = 25,
+        X_GrabPointer = 26,
+        X_UngrabPointer = 27,
+        X_GrabButton = 28,
+        X_UngrabButton = 29,
+        X_ChangeActivePointerGrab = 30,
+        X_GrabKeyboard = 31,
+        X_UngrabKeyboard = 32,
+        X_GrabKey = 33,
+        X_UngrabKey = 34,
+        X_AllowEvents = 35,
+        X_GrabServer = 36,
+        X_UngrabServer = 37,
+        X_QueryPointer = 38,
+        X_GetMotionEvents = 39,
+        X_TranslateCoords = 40,
+        X_WarpPointer = 41,
+        X_SetInputFocus = 42,
+        X_GetInputFocus = 43,
+        X_QueryKeymap = 44,
+        X_OpenFont = 45,
+        X_CloseFont = 46,
+        X_QueryFont = 47,
+        X_QueryTextExtents = 48,
+        X_ListFonts = 49,
+        X_ListFontsWithInfo = 50,
+        X_SetFontPath = 51,
+        X_GetFontPath = 52,
+        X_CreatePixmap = 53,
+        X_FreePixmap = 54,
+        X_CreateGC = 55,
+        X_ChangeGC = 56,
+        X_CopyGC = 57,
+        X_SetDashes = 58,
+        X_SetClipRectangles = 59,
+        X_FreeGC = 60,
+        X_ClearArea = 61,
+        X_CopyArea = 62,
+        X_CopyPlane = 63,
+        X_PolyPoint = 64,
+        X_PolyLine = 65,
+        X_PolySegment = 66,
+        X_PolyRectangle = 67,
+        X_PolyArc = 68,
+        X_FillPoly = 69,
+        X_PolyFillRectangle = 70,
+        X_PolyFillArc = 71,
+        X_PutImage = 72,
+        X_GetImage = 73,
+        X_PolyText8 = 74,
+        X_PolyText16 = 75,
+        X_ImageText8 = 76,
+        X_ImageText16 = 77,
+        X_CreateColormap = 78,
+        X_FreeColormap = 79,
+        X_CopyColormapAndFree = 80,
+        X_InstallColormap = 81,
+        X_UninstallColormap = 82,
+        X_ListInstalledColormaps = 83,
+        X_AllocColor = 84,
+        X_AllocNamedColor = 85,
+        X_AllocColorCells = 86,
+        X_AllocColorPlanes = 87,
+        X_FreeColors = 88,
+        X_StoreColors = 89,
+        X_StoreNamedColor = 90,
+        X_QueryColors = 91,
+        X_LookupColor = 92,
+        X_CreateCursor = 93,
+        X_CreateGlyphCursor = 94,
+        X_FreeCursor = 95,
+        X_RecolorCursor = 96,
+        X_QueryBestSize = 97,
+        X_QueryExtension = 98,
+        X_ListExtensions = 99,
+        X_ChangeKeyboardMapping = 100,
+        X_GetKeyboardMapping = 101,
+        X_ChangeKeyboardControl = 102,
+        X_GetKeyboardControl = 103,
+        X_Bell = 104,
+        X_ChangePointerControl = 105,
+        X_GetPointerControl = 106,
+        X_SetScreenSaver = 107,
+        X_GetScreenSaver = 108,
+        X_ChangeHosts = 109,
+        X_ListHosts = 110,
+        X_SetAccessControl = 111,
+        X_SetCloseDownMode = 112,
+        X_KillClient = 113,
+        X_RotateProperties = 114,
+        X_ForceScreenSaver = 115,
+        X_SetPointerMapping = 116,
+        X_GetPointerMapping = 117,
+        X_SetModifierMapping = 118,
+        X_GetModifierMapping = 119,
+        X_NoOperation = 127
+    }
+
+    [Flags]
+    internal enum XIMProperties
+    {
+        XIMPreeditArea = 0x0001,
+        XIMPreeditCallbacks = 0x0002,
+        XIMPreeditPosition = 0x0004,
+        XIMPreeditNothing = 0x0008,
+        XIMPreeditNone = 0x0010,
+        XIMStatusArea = 0x0100,
+        XIMStatusCallbacks = 0x0200,
+        XIMStatusNothing = 0x0400,
+        XIMStatusNone = 0x0800,
+    }
+
+    [Flags]
+    internal enum WindowType
+    {
+        Client = 1,
+        Whole = 2,
+        Both = 3
+    }
+
+    internal enum XEmbedMessage
+    {
+        EmbeddedNotify = 0,
+        WindowActivate = 1,
+        WindowDeactivate = 2,
+        RequestFocus = 3,
+        FocusIn = 4,
+        FocusOut = 5,
+        FocusNext = 6,
+        FocusPrev = 7,
+        /* 8-9 were used for XEMBED_GRAB_KEY/XEMBED_UNGRAB_KEY */
+        ModalityOn = 10,
+        ModalityOff = 11,
+        RegisterAccelerator = 12,
+        UnregisterAccelerator = 13,
+        ActivateAccelerator = 14
+    }
+
+    internal enum ImageFormat
+    {
+        XYPixmap = 1,
+        ZPixmap
+    }
+
+    // XInput2 structures
+
+    enum XIClassType
+    {
+        Button = 1,
+        Valuator = 2,
+        Scroll = 3,
+    }
+
+    enum XIScrollType
+    {
+        Vertical = 1,
+        Horizontal = 2
+    }
+
+    struct XIDeviceInfo
+    {
+        public int deviceid;
+        public IntPtr name; // byte*
+        public XIDeviceType use;
+        public int attachment;
+        public Bool enabled;
+        public int num_classes;
+        public IntPtr classes; // XIAnyClassInfo**
+    }
+
+    struct XIAnyClassInfo
+    {
+        public XIClassType type;
+        public int sourceid;
+    }
+
+    struct XIButtonClassInfo
+    {
+        public XIClassType type;
+        public int sourceid;
+        public int num_buttons;
+        public IntPtr labels; // Atom*
+        public XIButtonState state;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct XIScrollClassInfo
+    {
+        public XIClassType type;
+        public int sourceid;
+        public int number;
+        public XIScrollType scroll_type;
+        public double increment;
+        public int flags;
+    }
+
+    [StructLayout(LayoutKind.Sequential)]
+    struct XIValuatorClassInfo
+    {
+        public XIClassType type;
+        public int sourceid;
+        public int number;
+        public IntPtr label;
+        public double min;
+        public double max;
+        public double value;
+        public int resolution;
+        public XIMode mode;
+    }
+
+    struct XIDeviceEvent
+    {
+        public int           type;         /* GenericEvent */
+        public IntPtr serial;       /* # of last request processed by server */
+        public bool          send_event;   /* true if this came from a SendEvent request */
+        public IntPtr display;     /* Display the event was read from */
+        public int           extension;    /* XI extension offset */
+        public XIEventType           evtype;
+        public Time          time;
+        public int           deviceid;
+        public int           sourceid;
+        public int           detail;
+        public Window        root;
+        public Window        @event;
+        public Window        child;
+        public double        root_x;
+        public double        root_y;
+        public double        event_x;
+        public double        event_y;
+        public XIEventFlags        flags;
+        public XIButtonState       buttons;
+        public XIValuatorState     valuators;
+        public XIModifierState     mods;
+        public XIGroupState        @group;
+    }
+
+    struct XIRawEvent
+    {
+        public int           type;         /* GenericEvent */
+        public IntPtr serial;       /* # of last request processed by server */
+        public Bool          send_event;   /* true if this came from a SendEvent request */
+        public IntPtr display;     /* Display the event was read from */
+        public int           extension;    /* XI extension offset */
+        public XIEventType   evtype;       /* XI_RawKeyPress, XI_RawKeyRelease, etc. */
+        public Time          time;
+        public int           deviceid;
+        public int           sourceid;
+        public int           detail;
+        public XIEventFlags  flags;
+        public XIValuatorState valuators;
+        public IntPtr raw_values; // FP3232*
+    }
+
+    struct XIButtonState
+    {
+        public int           mask_len;
+        public IntPtr mask; // byte*
+    }
+
+    struct XIModifierState
+    {
+        public int    @base;
+        public int    latched;
+        public int    locked;
+        public int    effective;
+    }
+
+    struct XIGroupState
+    {
+        public int    @base;
+        public int    latched;
+        public int    locked;
+        public int    effective;
+    }
+
+    struct XIValuatorState
+    {
+        public int           mask_len;
+        public IntPtr mask; // byte*
+        public IntPtr values; // double*
+    }
+
+    struct XIEventMask : IDisposable
+    {
+        public int deviceid; // 0 = XIAllDevices, 1 = XIAllMasterDevices
+        int mask_len;
+        unsafe byte* mask;
+
+        public XIEventMask(int id, XIEventMasks m)
+        {
+            deviceid = id;
+            mask_len = sizeof(XIEventMasks);
+            unsafe
+            {
+                mask = (byte*)Marshal.AllocHGlobal(mask_len);
+                for (int i = 0; i < mask_len; i++)
+                    mask[i] = (byte)((uint)m >> i*8);
+            }
+        }
+
+        public void Dispose()
+        {
+            unsafe
+            {
+                Marshal.FreeHGlobal(new IntPtr((void*)mask));
+            }
+        }
+    }
+
+    enum XIEventType
+    {
+        DeviceChanged = 1,
+        KeyPress,
+        KeyRelease,
+        ButtonPress,
+        ButtonRelease,
+        Motion,
+        Enter,
+        Leave,
+        FocusIn,
+        FocusOut,
+        HierarchyChanged,
+        PropertyEvent,
+        RawKeyPress,
+        RawKeyRelease,
+        RawButtonPress,
+        RawButtonRelease,
+        RawMotion,
+        LastEvent = RawMotion
+    }
+
+    enum XIEventMasks
+    {
+        DeviceChangedMask =            (1 << (int)XIEventType.DeviceChanged),
+        KeyPressMask =                 (1 << (int)XIEventType.KeyPress),
+        KeyReleaseMask =               (1 << (int)XIEventType.KeyRelease),
+        ButtonPressMask =              (1 << (int)XIEventType.ButtonPress),
+        ButtonReleaseMask =            (1 << (int)XIEventType.ButtonRelease),
+        MotionMask =                   (1 << (int)XIEventType.Motion),
+        EnterMask =                    (1 << (int)XIEventType.Enter),
+        LeaveMask =                    (1 << (int)XIEventType.Leave),
+        FocusInMask =                  (1 << (int)XIEventType.FocusIn),
+        FocusOutMask =                 (1 << (int)XIEventType.FocusOut),
+        HierarchyChangedMask =         (1 << (int)XIEventType.HierarchyChanged),
+        PropertyEventMask =            (1 << (int)XIEventType.PropertyEvent),
+        RawKeyPressMask =              (1 << (int)XIEventType.RawKeyPress),
+        RawKeyReleaseMask =            (1 << (int)XIEventType.RawKeyRelease),
+        RawButtonPressMask =           (1 << (int)XIEventType.RawButtonPress),
+        RawButtonReleaseMask =         (1 << (int)XIEventType.RawButtonRelease),
+        RawMotionMask =                (1 << (int)XIEventType.RawMotion),
+    }
+
+    [Flags]
+    enum XIKeyEventFlags
+    {
+        Repeat = (1 << 16),
+    }
+
+    [Flags]
+    enum XIPointerEventFlags
+    {
+        Emulated = (1 << 16),
+    }
+
+    [Flags]
+    enum XITouchEventFlags
+    {
+        PendingEnd = (1 << 16),
+        EmulatingPointer = (1 << 17),
+    }
+
+    [Flags]
+    enum XIEventFlags
+    {
+        KeyRepeat = XIKeyEventFlags.Repeat,
+        PointerEmulated = XIPointerEventFlags.Emulated,
+        TouchPendingEnd = XITouchEventFlags.PendingEnd,
+        TouchEmulatingPointer = XITouchEventFlags.EmulatingPointer
+    }
+}