C# X11.X11WindowInfo类代码示例

        public X11GLContext(GraphicsMode mode, IWindowInfo window)
        {
            if (mode == null)
                throw new ArgumentNullException("mode");
            if (window == null)
                throw new ArgumentNullException("window");

            Debug.Print( "Creating X11GLContext context: " );
            currentWindow = (X11WindowInfo)window;
            Display = API.DefaultDisplay;
            XVisualInfo info = currentWindow.VisualInfo;
            Mode = GetGraphicsMode( info );
            // Cannot pass a Property by reference.
            ContextHandle = Glx.glXCreateContext(Display, ref info, IntPtr.Zero, true);

            if (ContextHandle == IntPtr.Zero) {
                Debug.Print("failed. Trying indirect... ");
                ContextHandle = Glx.glXCreateContext(Display, ref info, IntPtr.Zero, false);
            }

            if (ContextHandle != IntPtr.Zero)
                Debug.Print("Context created (id: {0}).", ContextHandle);
            else
                throw new GraphicsContextException("Failed to create OpenGL context. Glx.CreateContext call returned 0.");

            if (!Glx.glXIsDirect(Display, ContextHandle))
                Debug.Print("Warning: Context is not direct.");
        }

 public X11WindowInfo(IntPtr handle, X11WindowInfo parent)
 {
     this.handle = handle;
       this.parent = parent;
       if (parent == null)
     return;
       this.rootWindow = parent.rootWindow;
       this.display = parent.display;
       this.screen = parent.screen;
       this.visualInfo = parent.visualInfo;
 }

 public X11GLContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shared, bool direct,
     int major, int minor, GraphicsContextFlags flags)
     : base(DesktopBackend.OpenGL)
 {
     if (handle == ContextHandle.Zero)
         throw new ArgumentException("handle");
     if (window == null)
         throw new ArgumentNullException("window");
     Handle = handle;
     currentWindow = (X11WindowInfo)window;
     Display = currentWindow.Display;
 }

 public static void SendNetClientMessage(X11WindowInfo window, IntPtr message_type, IntPtr l0, IntPtr l1, IntPtr l2)
 {
     Functions.XSendEvent(window.Display, window.WindowHandle, false, new IntPtr(0), ref new XEvent()
       {
     ClientMessageEvent = {
       type = XEventName.ClientMessage,
       send_event = true,
       window = window.WindowHandle,
       message_type = message_type,
       format = 32,
       ptr1 = l0,
       ptr2 = l1,
       ptr3 = l2
     }
       });
 }

        public static void SendNetClientMessage(X11WindowInfo window, IntPtr message_type,
                                                IntPtr l0, IntPtr l1, IntPtr l2)
        {
            XEvent xev;

            xev = new XEvent();
            xev.ClientMessageEvent.type = XEventName.ClientMessage;
            xev.ClientMessageEvent.send_event = true;
            xev.ClientMessageEvent.window = window.WindowHandle;
            xev.ClientMessageEvent.message_type = message_type;
            xev.ClientMessageEvent.format = 32;
            xev.ClientMessageEvent.ptr1 = l0;
            xev.ClientMessageEvent.ptr2 = l1;
            xev.ClientMessageEvent.ptr3 = l2;

            XSendEvent(window.Display, window.WindowHandle, false, new IntPtr((int)EventMask.NoEventMask), ref xev);
        }

 static IntPtr CreateEmptyCursor(X11WindowInfo window)
 {
     IntPtr cursor = IntPtr.Zero;
     using (new XLock(window.Display))
     {
         XColor black, dummy;
         IntPtr cmap = Functions.XDefaultColormap(window.Display, window.Screen);
         Functions.XAllocNamedColor(window.Display, cmap, "black", out black, out dummy);
         IntPtr bmp_empty = Functions.XCreateBitmapFromData(window.Display,
             window.Handle, new byte[,] { { 0 } });
         cursor = Functions.XCreatePixmapCursor(window.Display,
             bmp_empty, bmp_empty, ref black, ref black, 0, 0);
     }
     return cursor;
 }

        public override void MakeCurrent(IWindowInfo window)
        {
            if (window == currentWindow && IsCurrent)
                return;

            if (window != null && ((X11WindowInfo)window).Display != Display)
                throw new InvalidOperationException("MakeCurrent() may only be called on windows originating from the same display that spawned this GL context.");

            if (window == null)
            {
                Debug.Write(String.Format("Releasing context {0} from thread {1} (Display: {2})... ",
                        Handle, System.Threading.Thread.CurrentThread.ManagedThreadId, Display));

                bool result;
                using (new XLock(Display))
                {
                    result = Glx.MakeCurrent(Display, IntPtr.Zero, IntPtr.Zero);
                    if (result)
                    {
                        currentWindow = null;
                    }
                }
                Debug.Print("{0}", result ? "done!" : "failed.");
            }
            else
            {
                X11WindowInfo w = (X11WindowInfo)window;
                bool result;

                Debug.Write(String.Format("Making context {0} current on thread {1} (Display: {2}, Screen: {3}, Window: {4})... ",
                        Handle, System.Threading.Thread.CurrentThread.ManagedThreadId, Display, w.Screen, w.Handle));

                if (Display == IntPtr.Zero || w.Handle == IntPtr.Zero || Handle == ContextHandle.Zero)
                    throw new InvalidOperationException("Invalid display, window or context.");

                using (new XLock(Display))
                {
                    result = Glx.MakeCurrent(Display, w.Handle, Handle);
                    if (result)
                    {
                        currentWindow = w;
                    }
                }

                if (!result)
                    throw new GraphicsContextException("Failed to make context current.");
                else
                    Debug.WriteLine("done!");
            }

            currentWindow = (X11WindowInfo)window;
        }

        static bool SupportsExtension(IntPtr display, X11WindowInfo window, string e)
        {
            if (window == null)
                throw new ArgumentNullException("window");
            if (e == null)
                throw new ArgumentNullException("e");
            if (window.Display != display)
                throw new InvalidOperationException();

            string extensions = null;
            using (new XLock(display))
            {
                extensions = Glx.QueryExtensionsString(display, window.Screen);
            }
            return !String.IsNullOrEmpty(extensions) && extensions.Contains(e);
        }

 public unsafe X11GLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shared, bool direct, int major, int minor, GraphicsContextFlags flags)
 {
     if (mode == null)
     throw new ArgumentNullException("mode");
       if (window == null)
     throw new ArgumentNullException("window");
       this.Mode = mode;
       this.Display = ((X11WindowInfo) window).Display;
       this.currentWindow = (X11WindowInfo) window;
       this.currentWindow.VisualInfo = this.SelectVisual(mode, this.currentWindow);
       ContextHandle contextHandle = shared != null ? (shared as IGraphicsContextInternal).Context : (ContextHandle) IntPtr.Zero;
       if (!this.glx_loaded)
       {
     XVisualInfo visualInfo = this.currentWindow.VisualInfo;
     IntPtr num = IntPtr.Zero;
     using (new XLock(this.Display))
     {
       num = Glx.CreateContext(this.Display, ref visualInfo, IntPtr.Zero, true);
       if (num == IntPtr.Zero)
     num = Glx.CreateContext(this.Display, ref visualInfo, IntPtr.Zero, false);
     }
     if (num != IntPtr.Zero)
     {
       new Glx().LoadEntryPoints();
       using (new XLock(this.Display))
     Glx.MakeCurrent(this.Display, IntPtr.Zero, IntPtr.Zero);
       this.glx_loaded = true;
     }
       }
       if (major * 10 + minor >= 30 && Glx.Delegates.glXCreateContextAttribsARB != null)
       {
     int fbount;
     IntPtr* numPtr = Glx.ChooseFBConfig(this.Display, this.currentWindow.Screen, new int[3]
     {
       32779,
       (int) mode.Index.Value,
       0
     }, out fbount);
     if (fbount > 0)
     {
       List<int> list = new List<int>();
       list.Add(8337);
       list.Add(major);
       list.Add(8338);
       list.Add(minor);
       if (flags != GraphicsContextFlags.Default)
       {
     list.Add(8340);
     list.Add((int) flags);
       }
       list.Add(0);
       list.Add(0);
       using (new XLock(this.Display))
       {
     this.Handle = new ContextHandle(Glx.Arb.CreateContextAttribs(this.Display, *numPtr, contextHandle.Handle, direct, list.ToArray()));
     if (this.Handle == ContextHandle.Zero)
       this.Handle = new ContextHandle(Glx.Arb.CreateContextAttribs(this.Display, *numPtr, contextHandle.Handle, !direct, list.ToArray()));
       }
       int num = this.Handle == ContextHandle.Zero ? 1 : 0;
       using (new XLock(this.Display))
     Functions.XFree((IntPtr) ((void*) numPtr));
     }
       }
       if (this.Handle == ContextHandle.Zero)
       {
     XVisualInfo visualInfo = this.currentWindow.VisualInfo;
     using (new XLock(this.Display))
     {
       this.Handle = new ContextHandle(Glx.CreateContext(this.Display, ref visualInfo, contextHandle.Handle, direct));
       if (this.Handle == ContextHandle.Zero)
     this.Handle = new ContextHandle(Glx.CreateContext(this.Display, ref visualInfo, IntPtr.Zero, !direct));
     }
       }
       if (!(this.Handle != ContextHandle.Zero))
     throw new GraphicsContextException("Failed to create OpenGL context. Glx.CreateContext call returned 0.");
       using (new XLock(this.Display))
     Glx.IsDirect(this.Display, this.Handle.Handle);
 }

 void DrawDirect( FastBitmap bmp, uint bits, X11WindowInfo x11Info )
 {
     IntPtr image = API.XCreateImage( API.DefaultDisplay, x11Info.VisualInfo.Visual,
                                     bits, ImageFormat.ZPixmap, 0, bmp.Scan0,
                                     bmp.Width, bmp.Height, 32, 0 );
     API.XPutImage( API.DefaultDisplay, x11Info.WindowHandle, gc, image,
                   0, 0, 0, 0, bmp.Width, bmp.Height );
     API.XFree( image );
 }

        public X11GLContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shared, bool direct,
            int major, int minor, GraphicsContextFlags flags)
        {
            if (mode == null)
                throw new ArgumentNullException("mode");
            if (window == null)
                throw new ArgumentNullException("window");

            // Do not move this lower, as almost everything requires the Display
            // property to be correctly set.
            Display = ((X11WindowInfo)window).Display;

            // Check that GLX is supported. We cannot proceed to create
            // an OpenGL context without the GLX extension.
            int error_base;
            int event_base;
            int glx_major;
            int glx_minor;
            using (new XLock(Display))
            {
                bool supported = Glx.QueryExtension(Display, out error_base, out event_base);
                supported &= Glx.QueryVersion(Display, out glx_major, out glx_minor);
                if (supported)
                {
                    Debug.Print("[X11] GLX supported. Version is {0}.{1}", glx_major, glx_minor);
                }
                else
                {
                    throw new NotSupportedException("[X11] GLX extension is not supported.");
                }
            }

            IntPtr visual = IntPtr.Zero;
            IntPtr fbconfig = IntPtr.Zero;

            // Once a window has a visual, we cannot use a different
            // visual on the OpenGL context, or glXMakeCurrent might fail.
            // Note: we should only check X11WindowInfo.Visual, as that
            // is the only property that can be set by Utilities.CreateX11WindowInfo.
            currentWindow = (X11WindowInfo)window;
            if (currentWindow.Visual != IntPtr.Zero)
            {
                visual = currentWindow.Visual;
                fbconfig = currentWindow.FBConfig;
                Mode = currentWindow.GraphicsMode;
            }

            if (Mode == null || !Mode.Index.HasValue)
            {
                Mode = ModeSelector.SelectGraphicsMode(mode, out visual, out fbconfig);
            }

            ContextHandle shareHandle = shared != null ?
                (shared as IGraphicsContextInternal).Context : (ContextHandle)IntPtr.Zero;
            
            Debug.Write("Creating X11GLContext context: ");
            Debug.Write(direct ? "direct, " : "indirect, ");
            Debug.WriteLine(shareHandle.Handle == IntPtr.Zero ? "not shared... " :
                String.Format("shared with ({0})... ", shareHandle));
            
            // Try using the new context creation method. If it fails, fall back to the old one.
            // For each of these methods, we try two times to create a context:
            // one with the "direct" flag intact, the other with the flag inversed.
            // HACK: It seems that Catalyst 9.1 - 9.4 on Linux have problems with contexts created through
            // GLX_ARB_create_context, including hideous input lag, no vsync and other madness.
            // Use legacy context creation if the user doesn't request a 3.0+ context.
            if (fbconfig != IntPtr.Zero && (major * 10 + minor >= 30) && SupportsCreateContextAttribs(Display, currentWindow))
            {
                Handle = CreateContextAttribs(Display, currentWindow.Screen,
                    fbconfig, direct, major, minor, flags, shareHandle);
            }
            
            if (Handle == ContextHandle.Zero)
            {
                Handle = CreateContextLegacy(Display, visual, direct, shareHandle);
            }
            
            if (Handle != ContextHandle.Zero)
                Debug.Print("Context created (id: {0}).", Handle);
            else
                throw new GraphicsContextException("Failed to create OpenGL context. Glx.CreateContext call returned 0.");

            using (new XLock(Display))
            {
                if (!Glx.IsDirect(Display, Handle.Handle))
                    Debug.Print("Warning: Context is not direct.");
            }
        }

        public override void MakeCurrent(IWindowInfo window)
        {
            if (window == currentWindow && IsCurrent)
                return;

            if (window == null) {
                Debug.Print("Releasing context {0} (Display: {1})... ", ContextHandle, Display);
                if (!Glx.glXMakeCurrent(Display, IntPtr.Zero, IntPtr.Zero))
                    Debug.Print("failed to release context");
            } else {
                X11WindowInfo w = (X11WindowInfo)window;
                Debug.Print("Making context {0} current (Display: {1}, Screen: {2}, Window: {3})... ", ContextHandle, Display, w.Screen, w.WindowHandle);

                if (Display == IntPtr.Zero || w.WindowHandle == IntPtr.Zero || ContextHandle == IntPtr.Zero)
                    throw new InvalidOperationException("Invalid display, window or context.");

                if (!Glx.glXMakeCurrent(Display, w.WindowHandle, ContextHandle))
                    throw new GraphicsContextException("Failed to make context current.");

            }
            currentWindow = (X11WindowInfo)window;
        }

        public XI2MouseKeyboard()
        {
            window = new X11WindowInfo();

            window.Display = Functions.XOpenDisplay(IntPtr.Zero);
            using (new XLock(window.Display))
            {
                window.Screen = Functions.XDefaultScreen(window.Display);
                window.RootWindow = Functions.XRootWindow(window.Display, window.Screen);
                window.Handle = window.RootWindow;

                KeyMap = new X11KeyMap(window.Display);
            }

            if (!IsSupported(window.Display))
                throw new NotSupportedException("XInput2 not supported.");

            using (new XLock(window.Display))
            using (XIEventMask mask = new XIEventMask(1,
                XIEventMasks.RawKeyPressMask |
                XIEventMasks.RawKeyReleaseMask |
                XIEventMasks.RawButtonPressMask |
                XIEventMasks.RawButtonReleaseMask |
                XIEventMasks.RawMotionMask |
                XIEventMasks.MotionMask |
                XIEventMasks.DeviceChangedMask |
                (XIEventMasks)(1 << (int)ExitEvent)))
            {
                XI.SelectEvents(window.Display, window.Handle, mask);
                UpdateDevices();
            }

            ProcessingThread = new Thread(ProcessEvents);
            ProcessingThread.IsBackground = true;
            ProcessingThread.Start();
        }

 private XVisualInfo SelectVisual(GraphicsMode mode, X11WindowInfo currentWindow)
 {
     XVisualInfo template = new XVisualInfo();
       template.VisualID = mode.Index.Value;
       template.Screen = currentWindow.Screen;
       lock (API.Lock)
       {
     int local_1;
     IntPtr local_2 = Functions.XGetVisualInfo(this.Display, XVisualInfoMask.ID | XVisualInfoMask.Screen, ref template, out local_1);
     if (local_1 == 0)
       throw new GraphicsModeException(string.Format("Invalid GraphicsMode specified ({0}).", (object) mode));
     template = (XVisualInfo) Marshal.PtrToStructure(local_2, typeof (XVisualInfo));
     Functions.XFree(local_2);
       }
       return template;
 }

 private bool SupportsExtension(X11WindowInfo window, string e)
 {
     if (window == null)
     throw new ArgumentNullException("window");
       if (e == null)
     throw new ArgumentNullException("e");
       if (window.Display != this.Display)
     throw new InvalidOperationException();
       string str = (string) null;
       using (new XLock(this.Display))
     str = Glx.QueryExtensionsString(this.Display, window.Screen);
       if (!string.IsNullOrEmpty(str))
     return str.Contains(e);
       else
     return false;
 }