Ejemplo n.º 1
0
 public unsafe QuartzDisplayDeviceDriver()
 {
     lock (QuartzDisplayDeviceDriver.display_lock)
       {
     IntPtr[] local_0 = new IntPtr[20];
     int local_1;
     fixed (IntPtr* fixed_0 = local_0)
     {
       int temp_15 = (int) CG.GetActiveDisplayList(20, fixed_0, out local_1);
     }
     for (int local_3 = 0; local_3 < local_1; ++local_3)
     {
       IntPtr local_4 = local_0[local_3];
       bool local_5 = local_3 == 0;
       CG.DisplayPixelsWide(local_4);
       CG.DisplayPixelsHigh(local_4);
       CFArray local_7 = new CFArray(CG.DisplayAvailableModes(local_4));
       DisplayResolution local_8 = (DisplayResolution) null;
       List<DisplayResolution> local_9 = new List<DisplayResolution>();
       CFDictionary local_11 = new CFDictionary(CG.DisplayCurrentMode(local_4));
       for (int local_12 = 0; local_12 < local_7.Count; ++local_12)
       {
     CFDictionary local_13 = new CFDictionary(local_7[local_12]);
     int local_14 = (int) local_13.GetNumberValue("Width");
     int local_15 = (int) local_13.GetNumberValue("Height");
     int local_16 = (int) local_13.GetNumberValue("BitsPerPixel");
     double local_17 = local_13.GetNumberValue("RefreshRate");
     bool local_18 = local_11.Ref == local_13.Ref;
     DisplayResolution local_19 = new DisplayResolution(0, 0, local_14, local_15, local_16, (float) local_17);
     local_9.Add(local_19);
     if (local_18)
       local_8 = local_19;
       }
       HIRect local_20 = CG.DisplayBounds(local_4);
       Rectangle local_21 = new Rectangle((int) local_20.Origin.X, (int) local_20.Origin.Y, (int) local_20.Size.Width, (int) local_20.Size.Height);
       DisplayDevice local_22 = new DisplayDevice(local_8, local_5, (IEnumerable<DisplayResolution>) local_9, local_21, (object) local_4);
       this.AvailableDevices.Add(local_22);
       if (local_5)
     this.Primary = local_22;
     }
       }
 }
        public QuartzDisplayDeviceDriver()
        {
            lock (display_lock)
            {
                // To minimize the need to add static methods to OpenTK.Graphics.DisplayDevice
                // we only allow settings to be set through its constructor.
                // Thus, we save all necessary parameters in temporary variables
                // and construct the device when every needed detail is available.
                // The main DisplayDevice constructor adds the newly constructed device
                // to the list of available devices.
                const int maxDisplayCount = 20;
                IntPtr[] displays = new IntPtr[maxDisplayCount];
                int displayCount;
                
                unsafe
                {
                    fixed (IntPtr* displayPtr = displays)
                    {
                        CG.GetActiveDisplayList(maxDisplayCount, displayPtr, out displayCount);
                    }
                }
                
                Debug.Print("CoreGraphics reported {0} display(s).", displayCount);
                Debug.Indent();
                
                for (int i = 0; i < displayCount; i++)
                {
                    IntPtr currentDisplay = displays[i];
                    
                    // according to docs, first element in the array is always the
                    // main display.
                    bool primary = (i == 0);
                    
                    // gets current settings
                    int currentWidth = CG.DisplayPixelsWide(currentDisplay);
                    int currentHeight = CG.DisplayPixelsHigh(currentDisplay);
                    Debug.Print("Display {0} is at  {1}x{2}", i, currentWidth, currentHeight);
                    
                    IntPtr displayModesPtr = CG.DisplayAvailableModes(currentDisplay);
                    CFArray displayModes = new CFArray(displayModesPtr);
                    Debug.Print("Supports {0} display modes.", displayModes.Count);
                    
                    DisplayResolution opentk_dev_current_res = null;
                    List<DisplayResolution> opentk_dev_available_res = new List<DisplayResolution>();
                    IntPtr currentModePtr = CG.DisplayCurrentMode(currentDisplay);
                    CFDictionary currentMode = new CFDictionary(currentModePtr);
                    
                    for (int j = 0; j < displayModes.Count; j++)
                    {
                        CFDictionary dict = new CFDictionary(displayModes[j]);
                        
                        int width = (int)dict.GetNumberValue("Width");
                        int height = (int)dict.GetNumberValue("Height");
                        int bpp = (int)dict.GetNumberValue("BitsPerPixel");
                        double freq = dict.GetNumberValue("RefreshRate");
                        bool current = currentMode.Ref == dict.Ref;
                        
                        //if (current) Debug.Write("  * ");
                        //else Debug.Write("    ");
                        
                        //Debug.Print("Mode {0} is {1}x{2}x{3} @ {4}.", j, width, height, bpp, freq);
                        
                        DisplayResolution thisRes = new DisplayResolution(0, 0, width, height, bpp, (float)freq);
                        opentk_dev_available_res.Add(thisRes);
                        
                        if (current)
                            opentk_dev_current_res = thisRes;
                        
                    }
                    
                    HIRect bounds = CG.DisplayBounds(currentDisplay);
                    Rectangle newRect = new Rectangle((int)bounds.Origin.X, (int)bounds.Origin.Y, (int)bounds.Size.Width, (int)bounds.Size.Height);
                    
                    Debug.Print("Display {0} bounds: {1}", i, newRect);
                    
                    DisplayDevice opentk_dev = new DisplayDevice(opentk_dev_current_res,
                        primary, opentk_dev_available_res, newRect, currentDisplay);

                    AvailableDevices.Add(opentk_dev);

                    if (primary)
                        Primary = opentk_dev;
                }
                
                Debug.Unindent();
            }
        }
 public sealed override bool TryChangeResolution(DisplayDevice device, DisplayResolution resolution)
 {
     IntPtr display = HandleTo(device);
     IntPtr currentModePtr = CG.DisplayCurrentMode(display);
     
     if (storedModes.ContainsKey(display) == false)
     {
         storedModes.Add(display, currentModePtr);
     }
     
     IntPtr displayModesPtr = CG.DisplayAvailableModes(display);
     CFArray displayModes = new CFArray(displayModesPtr);
     
     for (int j = 0; j < displayModes.Count; j++)
     {
         CFDictionary dict = new CFDictionary(displayModes[j]);
         
         int width = (int)dict.GetNumberValue("Width");
         int height = (int)dict.GetNumberValue("Height");
         int bpp = (int)dict.GetNumberValue("BitsPerPixel");
         double freq = dict.GetNumberValue("RefreshRate");
         
         if (width == resolution.Width && height == resolution.Height && bpp == resolution.BitsPerPixel && System.Math.Abs(freq - resolution.RefreshRate) < 1e-6)
         {
             if (displaysCaptured.Contains(display) == false)
             {
                 CG.DisplayCapture(display);
             }
             
             Debug.Print("Changing resolution to {0}x{1}x{2}@{3}.", width, height, bpp, freq);
             
             CG.DisplaySwitchToMode(display, displayModes[j]);
             
             return true;
         }
         
     }
     return false;
 }
Ejemplo n.º 4
0
 public override sealed bool TryChangeResolution(DisplayDevice device, DisplayResolution resolution)
 {
     IntPtr num1 = QuartzDisplayDeviceDriver.HandleTo(device);
       IntPtr num2 = CG.DisplayCurrentMode(num1);
       if (!this.storedModes.ContainsKey(num1))
     this.storedModes.Add(num1, num2);
       CFArray cfArray = new CFArray(CG.DisplayAvailableModes(num1));
       for (int index = 0; index < cfArray.Count; ++index)
       {
     CFDictionary cfDictionary = new CFDictionary(cfArray[index]);
     int num3 = (int) cfDictionary.GetNumberValue("Width");
     int num4 = (int) cfDictionary.GetNumberValue("Height");
     int num5 = (int) cfDictionary.GetNumberValue("BitsPerPixel");
     double numberValue = cfDictionary.GetNumberValue("RefreshRate");
     if (num3 == resolution.Width && num4 == resolution.Height && (num5 == resolution.BitsPerPixel && Math.Abs(numberValue - (double) resolution.RefreshRate) < 1E-06))
     {
       if (!this.displaysCaptured.Contains(num1))
       {
     int num6 = (int) CG.DisplayCapture(num1);
       }
       CG.DisplaySwitchToMode(num1, cfArray[index]);
       return true;
     }
       }
       return false;
 }