C# MacOS.CarbonWindowInfo类代码示例

        public AglContext(GraphicsMode mode, IWindowInfo window, IGraphicsContext shareContext)
        {
            Debug.Print("Context Type: {0}", shareContext);
            Debug.Print("Window info: {0}", window);

            this.graphics_mode = mode;
            this.carbonWindow = (CarbonWindowInfo)window;

            if (shareContext is AglContext)
                shareContextRef = ((AglContext)shareContext).Handle.Handle;
			if (shareContext is GraphicsContext)
			{
				ContextHandle shareHandle = shareContext != null ?
					(shareContext as IGraphicsContextInternal).Context : (ContextHandle)IntPtr.Zero;

				shareContextRef = shareHandle.Handle;
			}

			if (shareContextRef == IntPtr.Zero)
			{
				Debug.Print("No context sharing will take place.");
			}

            CreateContext(mode, carbonWindow, shareContextRef, true);
        }

        public AglContext(GraphicsMode mode, IWindowInfo window)
        {
            Debug.Print("Window info: {0}", window);

            Mode = mode;
            this.carbonWindow = (CarbonWindowInfo)window;

            CreateContext(mode, carbonWindow, true);
        }

 public AglContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext)
 {
     if (handle == ContextHandle.Zero)
     throw new ArgumentException("handle");
       if (window == null)
     throw new ArgumentNullException("window");
       this.Handle = handle;
       this.carbonWindow = (CarbonWindowInfo) window;
 }

 public AglContext(ContextHandle handle, IWindowInfo window, IGraphicsContext shareContext)
     : base(DesktopBackend.OpenGL)
 {
     if (handle == ContextHandle.Zero)
         throw new ArgumentException("handle");
     if (window == null)
         throw new ArgumentNullException("window");
     Handle = handle;
     carbonWindow = (CarbonWindowInfo)window;
 }

 private IntPtr GetQuartzDevice(CarbonWindowInfo carbonWindow)
 {
     IntPtr windowRef = carbonWindow.WindowRef;
       if (!CarbonGLNative.WindowRefMap.ContainsKey(windowRef))
     return IntPtr.Zero;
       WeakReference weakReference = CarbonGLNative.WindowRefMap[windowRef];
       if (!weakReference.IsAlive)
     return IntPtr.Zero;
       CarbonGLNative carbonGlNative = weakReference.Target as CarbonGLNative;
       if (carbonGlNative == null)
     return IntPtr.Zero;
       else
     return QuartzDisplayDeviceDriver.HandleTo(carbonGlNative.TargetDisplayDevice);
 }

 internal void SetFullScreen(CarbonWindowInfo info, out int width, out int height)
 {
     CarbonGLNative wind = GetCarbonWindow(info);
     
     Debug.Print("Switching to full screen {0}x{1} on context {2}", wind.TargetDisplayDevice.Width, wind.TargetDisplayDevice.Height, Handle.Handle);
     
     CG.DisplayCapture(GetQuartzDevice(info));
     Agl.aglSetFullScreen(Handle.Handle, wind.TargetDisplayDevice.Width, wind.TargetDisplayDevice.Height, 0, 0);
     MakeCurrent(info);
     
     width = wind.TargetDisplayDevice.Width;
     height = wind.TargetDisplayDevice.Height;
     
     // This is a weird hack to workaround a bug where the first time a context
     // is made fullscreen, we just end up with a blank screen.  So we undo it as fullscreen
     // and redo it as fullscreen.  
     if (firstFullScreen == false)
     {
         firstFullScreen = true;
         UnsetFullScreen(info);
         SetFullScreen(info, out width, out height);
     }
     
     mIsFullscreen = true;
 }

        private static IntPtr GetWindowPortForWindowInfo(CarbonWindowInfo carbonWindow)
        {
            IntPtr windowPort;
            if (carbonWindow.IsControl)
            {
                IntPtr controlOwner = API.GetControlOwner(carbonWindow.WindowRef);
                
                windowPort = API.GetWindowPort(controlOwner);
            }

            else
                windowPort = API.GetWindowPort(carbonWindow.WindowRef);
            
            return windowPort;
        }

        void SetBufferRect(CarbonWindowInfo carbonWindow)
        {
            if (carbonWindow.IsControl == false)
                return;

            // Todo: See if there is a way around using WinForms.
            throw new NotImplementedException();
#if false
            System.Windows.Forms.Control ctrl = Control.FromHandle(carbonWindow.WindowRef);
            
            if (ctrl.TopLevelControl == null)
                return;
            
            Rect rect = API.GetControlBounds(carbonWindow.WindowRef);
            System.Windows.Forms.Form frm = (System.Windows.Forms.Form)ctrl.TopLevelControl;
            
            System.Drawing.Point loc = frm.PointToClient(ctrl.PointToScreen(System.Drawing.Point.Empty));
            
            rect.X = (short)loc.X;
            rect.Y = (short)loc.Y;
            
            Debug.Print("Setting buffer_rect for control.");
            Debug.Print("MacOS Coordinate Rect:   {0}", rect);
            
            rect.Y = (short)(ctrl.TopLevelControl.ClientSize.Height - rect.Y - rect.Height);
            Debug.Print("  AGL Coordinate Rect:   {0}", rect);
            
            int[] glrect = new int[4];
            
            glrect[0] = rect.X;
            glrect[1] = rect.Y;
            glrect[2] = rect.Width;
            glrect[3] = rect.Height;
            
            Agl.aglSetInteger(Handle.Handle, Agl.ParameterNames.AGL_BUFFER_RECT, glrect);
            MyAGLReportError("aglSetInteger");
            
            Agl.aglEnable(Handle.Handle, Agl.ParameterNames.AGL_BUFFER_RECT);
            MyAGLReportError("aglEnable");
#endif
        }

        void CreateContext(GraphicsMode mode, CarbonWindowInfo carbonWindow, IntPtr shareContextRef, bool fullscreen)
        {
            List<int> aglAttributes = new List<int>();
            
            Debug.Print("AGL pixel format attributes:");
            Debug.Indent();
            
            AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_RGBA);
            AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_DOUBLEBUFFER);
            AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_RED_SIZE, mode.ColorFormat.Red);
            AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_GREEN_SIZE, mode.ColorFormat.Green);
            AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_BLUE_SIZE, mode.ColorFormat.Blue);
            AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_ALPHA_SIZE, mode.ColorFormat.Alpha);
            
            if (mode.Depth > 0)
                AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_DEPTH_SIZE, mode.Depth);
            
            if (mode.Stencil > 0)
                AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_STENCIL_SIZE, mode.Stencil);
            
            if (mode.AccumulatorFormat.BitsPerPixel > 0)
            {
                AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_ACCUM_RED_SIZE, mode.AccumulatorFormat.Red);
                AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_ACCUM_GREEN_SIZE, mode.AccumulatorFormat.Green);
                AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_ACCUM_BLUE_SIZE, mode.AccumulatorFormat.Blue);
                AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_ACCUM_ALPHA_SIZE, mode.AccumulatorFormat.Alpha);
            }
            
            if (mode.Samples > 1)
            {
                AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_SAMPLE_BUFFERS_ARB, 1);
                AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_SAMPLES_ARB, mode.Samples);
            }
            
            if (fullscreen)
            {
                AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_FULLSCREEN);
            }
            AddPixelAttrib(aglAttributes, Agl.PixelFormatAttribute.AGL_NONE);
            
            Debug.Unindent();
            
            Debug.Write("Attribute array:  ");
            for (int i = 0; i < aglAttributes.Count; i++)
                Debug.Write(aglAttributes[i].ToString() + "  ");
            Debug.WriteLine("");
            
            AGLPixelFormat myAGLPixelFormat;
            
            // Choose a pixel format with the attributes we specified.
            if (fullscreen)
            {
                IntPtr gdevice;
                IntPtr cgdevice = GetQuartzDevice(carbonWindow);
                
                if (cgdevice == IntPtr.Zero)
                    cgdevice = (IntPtr)DisplayDevice.Default.Id;
                
                OSStatus status = Carbon.API.DMGetGDeviceByDisplayID(cgdevice, out gdevice, false);
                
                if (status != OSStatus.NoError)
                    throw new MacOSException(status, "DMGetGDeviceByDisplayID failed.");
                
                myAGLPixelFormat = Agl.aglChoosePixelFormat(ref gdevice, 1, aglAttributes.ToArray());
                
                Agl.AglError err = Agl.GetError();
                
                if (err == Agl.AglError.BadPixelFormat)
                {
                    Debug.Print("Failed to create full screen pixel format.");
                    Debug.Print("Trying again to create a non-fullscreen pixel format.");
                    
                    CreateContext(mode, carbonWindow, shareContextRef, false);
                    return;
                }
            }

            else
            {
                myAGLPixelFormat = Agl.aglChoosePixelFormat(IntPtr.Zero, 0, aglAttributes.ToArray());
                
                MyAGLReportError("aglChoosePixelFormat");
            }
            
            
            Debug.Print("Creating AGL context.  Sharing with {0}", shareContextRef);
            
            // create the context and share it with the share reference.
            Handle = new ContextHandle(Agl.aglCreateContext(myAGLPixelFormat, shareContextRef));
            MyAGLReportError("aglCreateContext");
            
            // Free the pixel format from memory.
            Agl.aglDestroyPixelFormat(myAGLPixelFormat);
            MyAGLReportError("aglDestroyPixelFormat");
            
            Debug.Print("IsControl: {0}", carbonWindow.IsControl);
            
            SetDrawable(carbonWindow);
            SetBufferRect(carbonWindow);
            Update(carbonWindow);
//.........这里部分代码省略.........

 private void SetDrawable(CarbonWindowInfo carbonWindow)
 {
     Agl.aglSetDrawable(this.Handle.Handle, AglContext.GetWindowPortForWindowInfo(carbonWindow));
       this.MyAGLReportError("aglSetDrawable");
 }

 private void SetBufferRect(CarbonWindowInfo carbonWindow)
 {
     if (carbonWindow.IsControl)
     throw new NotImplementedException();
 }

        void CreateContext(GraphicsMode mode, CarbonWindowInfo carbonWindow, IntPtr shareContextRef, bool fullscreen)
        {
            Debug.Print("AGL pixel format attributes:");
            
            AGLPixelFormat myAGLPixelFormat;
            
            // Choose a pixel format with the attributes we specified.
            IntPtr gdevice;
            IntPtr cgdevice = GetQuartzDevice(carbonWindow);
                
            if (cgdevice == IntPtr.Zero)
                cgdevice = (IntPtr)DisplayDevice.Default.Id;
                
            OSStatus status = Carbon.API.DMGetGDeviceByDisplayID(cgdevice, out gdevice, false);
                
            if (status != OSStatus.NoError)
                throw new MacOSException(status, "DMGetGDeviceByDisplayID failed.");

            IGraphicsMode selector = new MacOSGraphicsMode(gdevice);
            Mode = selector.SelectGraphicsMode(
                mode.ColorFormat, mode.Depth, mode.Stencil, mode.Samples,
                mode.AccumulatorFormat, mode.Buffers, mode.Stereo);
            MyAGLReportError("aglChoosePixelFormat");

            Debug.Print("Creating AGL context.  Sharing with {0}", shareContextRef);
            myAGLPixelFormat = Mode.Index.Value;

            // create the context and share it with the share reference.
            Handle = new ContextHandle(Agl.aglCreateContext(myAGLPixelFormat, shareContextRef));
            MyAGLReportError("aglCreateContext");

            // Free the pixel format from memory.
            Agl.aglDestroyPixelFormat(myAGLPixelFormat);
            MyAGLReportError("aglDestroyPixelFormat");
            
            Debug.Print("IsControl: {0}", carbonWindow.IsControl);
            
            SetDrawable(carbonWindow);
            SetBufferRect(carbonWindow);
            Update(carbonWindow);
            
            MakeCurrent(carbonWindow);
            Debug.Print("context: {0}", Handle.Handle);
        }

        void SetBufferRect(CarbonWindowInfo carbonWindow)
        {
            if (carbonWindow.IsControl == false)
                return;

            Rect rect = API.GetControlBounds(carbonWindow.WindowHandle);
            
            Debug.Print("Setting buffer_rect for control.");
            Debug.Print("MacOS Coordinate Rect:   {0}", rect);
            int[] glrect = new int[4];

            if (carbonWindow.XOffset != null)
                glrect[0] = rect.X + carbonWindow.XOffset();
            else
                glrect[0] = rect.X;
            if (carbonWindow.YOffset != null)
                glrect[1] = rect.Y + carbonWindow.YOffset();
            else
                glrect[1] = rect.Y;
            glrect[2] = rect.Width;
            glrect[3] = rect.Height;
            
            Agl.aglSetInteger(Handle.Handle, Agl.ParameterNames.AGL_BUFFER_RECT, glrect);
            MyAGLReportError("aglSetInteger");
            
            Agl.aglEnable(Handle.Handle, Agl.ParameterNames.AGL_BUFFER_RECT);
            MyAGLReportError("aglEnable");
        }

 private IntPtr GetQuartzDevice(CarbonWindowInfo carbonWindow)
 {
     IntPtr windowRef = carbonWindow.WindowRef;
     
     if (CarbonGLNative.WindowRefMap.ContainsKey(windowRef) == false)
         return IntPtr.Zero;
     
     WeakReference nativeRef = CarbonGLNative.WindowRefMap[windowRef];
     if (nativeRef.IsAlive == false)
         return IntPtr.Zero;
     
     CarbonGLNative window = nativeRef.Target as CarbonGLNative;
     
     if (window == null)
         return IntPtr.Zero;
     
     return QuartzDisplayDeviceDriver.HandleTo(window.TargetDisplayDevice);
     
 }

 protected virtual void Dispose(bool disposing)
 {
   if (this.mIsDisposed)
     return;
   this.CursorVisible = true;
   API.DisposeWindow(this.window.WindowRef);
   this.mIsDisposed = true;
   this.mExists = false;
   int num = (int) CG.SetLocalEventsSuppressionInterval(0.25);
   if (disposing)
   {
     CarbonGLNative.mWindows.Remove(this.window.WindowRef);
     this.window.Dispose();
     this.window = (CarbonWindowInfo) null;
   }
   this.DisposeUPP();
   this.Disposed((object) this, EventArgs.Empty);
 }