public RCode CreateWindowPane(VectorI2d vWindowPos, VectorI2d vWindowSize, bool bFullScreen)
        {
            display    = Xlib.XOpenDisplay(null);
            screen     = Xlib.XDefaultScreen(display);
            root       = Xlib.XRootWindow(display, screen);
            mainWindow = Xlib.XCreateSimpleWindow(
                display, root,
                vWindowPos.x, vWindowPos.y,
                (uint)vWindowSize.x, (uint)vWindowSize.y, 1,
                Xlib.XBlackPixel(display, screen), Xlib.XWhitePixel(display, screen));

            EventMask eventMask =
                // Keyboard
                EventMask.KeyPressMask | EventMask.KeyReleaseMask |
                // Mouse
                EventMask.PointerMotionMask | EventMask.ButtonPressMask | EventMask.ButtonReleaseMask |
                // Window
                EventMask.FocusChangeMask | EventMask.EnterWindowMask | EventMask.LeaveWindowMask;

            Xlib.XSelectInput(display, mainWindow, eventMask);
            Xlib.XMapWindow(display, mainWindow);

            // Disable windows re-sizing
            XSizeHints sizeHints = new XSizeHints()
            {
                flags      = XSizeHintsFlags.PMaxSize | XSizeHintsFlags.PMinSize,
                min_width  = vWindowSize.x,
                max_width  = vWindowSize.x,
                min_height = vWindowSize.y,
                max_height = vWindowSize.y
            };

            XlibExt.XSetWMNormalHints(display, mainWindow, ref sizeHints);

            // Setup delete message when the user closes the window
            deleteWindowMessage = XlibExt.XInternAtom(display, "WM_DELETE_WINDOW", false);
            XlibExt.XSetWMProtocols(display, mainWindow, new Atom[] { deleteWindowMessage }, 1);

            return(RCode.OK);
        }
        public RCode HandleSystemEvent()
        {
            while (Xlib.XPending(display) > 0)
            {
                Xlib.XNextEvent(display, ev);
                XAnyEvent xevent = Marshal.PtrToStructure <XAnyEvent>(ev);

                switch (xevent.type)
                {
                case (int)Event.ClientMessage:
                    XClientMessageEvent xClientMessageEvent = Marshal.PtrToStructure <XClientMessageEvent>(ev);
                    if (xClientMessageEvent.data == (IntPtr)deleteWindowMessage)
                    {
                        PixelGameEngine.Instance.Terminate();
                    }
                    break;

                case (int)Event.KeyPress:
                case (int)Event.KeyRelease:
                    XKeyEvent xKeyEvent = Marshal.PtrToStructure <XKeyEvent>(ev);
                    KeySym    sym       = XlibExt.XLookupKeysym(new XKeyEvent[] { xKeyEvent }, 0);
                    pge.Input.UpdateKeyState((int)mapKeys[(long)sym], xevent.type == (int)Event.KeyPress);
                    break;

                case (int)Event.ButtonPress:
                case (int)Event.ButtonRelease:
                    XButtonEvent xButtonEvent = Marshal.PtrToStructure <XButtonEvent>(ev);
                    bool         pressed      = xevent.type == (int)Event.ButtonPress;

                    switch (xButtonEvent.button)
                    {
                    case 1:
                    case 2:
                    case 3:
                        pge.Input.UpdateMouseState((int)xButtonEvent.button - 1, pressed);
                        break;

                    case 4:
                        pge.Input.UpdateMouseWheel(120);
                        break;

                    case 5:
                        pge.Input.UpdateMouseWheel(-120);
                        break;

                    case 6:
                    case 7:
                    case 8:
                    case 9:
                        pge.Input.UpdateMouseState((int)xButtonEvent.button - 3, pressed);
                        break;
                    }
                    break;

                case (int)Event.MotionNotify:
                    XMotionEvent xMotionEvent = Marshal.PtrToStructure <XMotionEvent>(ev);
                    pge.Input.UpdateMouse(xMotionEvent.x, xMotionEvent.y);
                    break;

                case (int)Event.EnterNotify:
                    pge.Input.UpdateMouseFocus(true);
                    break;

                case (int)Event.LeaveNotify:
                    pge.Input.UpdateMouseFocus(false);
                    break;

                case (int)Event.FocusIn:
                    pge.Input.UpdateKeyFocus(true);
                    break;

                case (int)Event.FocusOut:
                    pge.Input.UpdateKeyFocus(false);
                    break;
                }
            }
            return(RCode.OK);
        }