Ejemplo n.º 1
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);
        }
Ejemplo n.º 2
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;
                    }
                }
            }
        }
Ejemplo n.º 3
0
        public bool TryChangeResolution(DisplayDevice device, DisplayResolution resolution)
        {
            IntPtr display = displayMap[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 bool TryChangeResolution(DisplayDevice device, DisplayResolution resolution)
        {
            var display        = HandleTo(device);
            var currentModePtr = CG.DisplayCurrentMode(display);

            if (storedModes.ContainsKey(display) == false)
            {
                storedModes.Add(display, currentModePtr);
            }

            var displayModesPtr = CG.DisplayAvailableModes(display);
            var displayModes    = new CFArray(displayModesPtr);

            for (var j = 0; j < displayModes.Count; j++)
            {
                var dict = new CFDictionary(displayModes[j]);

                var width  = (int)dict.GetNumberValue("Width");
                var height = (int)dict.GetNumberValue("Height");
                var bpp    = (int)dict.GetNumberValue("BitsPerPixel");
                var freq   = dict.GetNumberValue("RefreshRate");

                if (width == resolution.Width && height == resolution.Height && bpp == resolution.BitsPerPixel &&
                    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.º 5
0
        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();
            }
        }
Ejemplo n.º 6
0
        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;
                var       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 (var i = 0; i < displayCount; i++)
                {
                    var currentDisplay = displays[i];

                    // according to docs, first element in the array is always the
                    // main display.
                    var primary = i == 0;

                    // gets current settings
                    var currentWidth  = CG.DisplayPixelsWide(currentDisplay);
                    var currentHeight = CG.DisplayPixelsHigh(currentDisplay);
                    Debug.Print("Display {0} is at  {1}x{2}", i, currentWidth, currentHeight);

                    var displayModesPtr = CG.DisplayAvailableModes(currentDisplay);
                    var displayModes    = new CFArray(displayModesPtr);
                    Debug.Print("Supports {0} display modes.", displayModes.Count);

                    DisplayResolution opentk_dev_current_res = null;
                    var opentk_dev_available_res             = new List <DisplayResolution>();
                    var currentModePtr = CG.DisplayCurrentMode(currentDisplay);
                    var currentMode    = new CFDictionary(currentModePtr);

                    for (var j = 0; j < displayModes.Count; j++)
                    {
                        var dict = new CFDictionary(displayModes[j]);

                        var width   = (int)dict.GetNumberValue("Width");
                        var height  = (int)dict.GetNumberValue("Height");
                        var bpp     = (int)dict.GetNumberValue("BitsPerPixel");
                        var freq    = dict.GetNumberValue("RefreshRate");
                        var current = currentMode.Ref == dict.Ref;

                        if (freq <= 0)
                        {
                            IntPtr displayLink;
                            CV.DisplayLinkCreateWithCGDisplay(currentDisplay, out displayLink);

                            var t = CV.DisplayLinkGetNominalOutputVideoRefreshPeriod(displayLink);
                            if ((t.flags & (int)CV.TimeFlags.TimeIsIndefinite) != (int)CV.TimeFlags.TimeIsIndefinite)
                            {
                                freq = (double)t.timeScale / t.timeValue;
                            }

                            CV.DisplayLinkRelease(displayLink);
                        }

                        //if (current) Debug.Write("  * ");
                        //else Debug.Write("    ");

                        //Debug.Print("Mode {0} is {1}x{2}x{3} @ {4}.", j, width, height, bpp, freq);

                        var thisRes = new DisplayResolution(0, 0, width, height, bpp, (float)freq);
                        opentk_dev_available_res.Add(thisRes);

                        if (current)
                        {
                            opentk_dev_current_res = thisRes;
                        }
                    }

                    var bounds  = CG.DisplayBounds(currentDisplay);
                    var newRect = new Rectangle((int)bounds.Location.X, (int)bounds.Location.Y,
                                                (int)bounds.Size.Width, (int)bounds.Size.Height);

                    Debug.Print("Display {0} bounds: {1}", i, newRect);

                    var 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();
            }
        }