예제 #1
0
        public DeskSet(int position, ConferenceAttendee attendee)
        {
            fPosition = position;
            fAttendee = attendee;

            // Desk Set Felt Pad

            // Bifold Monitor
            AABB boundary = new AABB(new NewTOAPIA.Vector3D(0.33f, 0.33f, 0.025f), new Point3D(0,1.025f,0));
            fMonitor = new DisplayMonitor(attendee.Session.Model.GI, boundary, new Resolution(1024,768));
            fMonitor.Rotate(-60, new float3(0, 1, 0));
            fMonitor.Translate(new Vector3D(-0.50f, 0.05f, 0.5f));

            // Create some viewers to receive images
            fDesktopViewer = new ReceivingTexture(attendee.Session.Model.GI, 620, 440);
            fWebcamViewer = new ReceivingTexture(attendee.Session.Model.GI, 352, 288);

            // Show the display on multiple monitors
            fMonitor.ImageSource = fWebcamViewer;
            attendee.Session.Model.Room.Whiteboard.ImageSource = fDesktopViewer;

            // Video Pedestal display

            // Whiteboard Pen Set

            AddChild(fMonitor);
        }
예제 #2
0
        //Move mouse cursor to target
        void MoveMousePosition()
        {
            try
            {
                //Get the current active screen
                int            monitorNumber          = Convert.ToInt32(Setting_Load(vConfigurationCtrlUI, "DisplayMonitor"));
                DisplayMonitor displayMonitorSettings = GetSingleMonitorEnumDisplay(monitorNumber);

                //Calculate target mouse position
                int windowTop    = (int)(this.Top * displayMonitorSettings.DpiScaleVertical);
                int windowLeft   = (int)(this.Left * displayMonitorSettings.DpiScaleHorizontal);
                int windowWidth  = (int)(this.ActualWidth * displayMonitorSettings.DpiScaleHorizontal);
                int windowHeight = (int)(this.ActualHeight * displayMonitorSettings.DpiScaleVertical);
                int targetWidth  = windowLeft + (windowWidth / 2);
                int targetHeight = windowTop - 30;

                //Check if target is outside screen
                if (targetHeight < 0)
                {
                    targetHeight = windowTop + windowHeight + 30;
                }
                if (targetWidth < 0)
                {
                    targetWidth = 30;
                }
                else if (targetWidth > displayMonitorSettings.WidthNative)
                {
                    targetWidth = displayMonitorSettings.WidthNative - 30;
                }

                //Move mouse cursor to target
                SetCursorPos(targetWidth, targetHeight);
            }
            catch { }
        }
예제 #3
0
        //Launch a Win32 application from databindapp
        async Task <bool> PrepareProcessLauncherWin32Async(DataBindApp dataBindApp, string launchArgument, bool silent, bool allowMinimize, bool runAsAdmin, bool createNoWindow, bool launchKeyboard)
        {
            bool appLaunched = false;

            try
            {
                //Set the app title
                string appTitle = dataBindApp.Name;

                //Check the launch argument
                if (string.IsNullOrWhiteSpace(launchArgument))
                {
                    launchArgument = dataBindApp.Argument;
                }
                else
                {
                    //Update the app title
                    if (dataBindApp.Category == AppCategory.Emulator)
                    {
                        appTitle += " with rom";
                    }
                    else if (dataBindApp.LaunchFilePicker)
                    {
                        appTitle += " with file";
                    }
                }

                //Chromium DPI launch argument
                string processName = Path.GetFileNameWithoutExtension(dataBindApp.PathExe);
                if (vCtrlChromiumBrowsers.Any(x => x.String1 == processName))
                {
                    //Get the current active screen
                    int            monitorNumber          = Convert.ToInt32(Setting_Load(vConfigurationCtrlUI, "DisplayMonitor"));
                    DisplayMonitor displayMonitorSettings = GetSingleMonitorEnumDisplay(monitorNumber);

                    //Get the current screen dpi
                    double screenDPI   = displayMonitorSettings.DpiScaleHorizontal;
                    double chromiumDPI = Convert.ToDouble(Setting_Load(vConfigurationCtrlUI, "AdjustChromiumDpi"));

                    //Update the launch argument
                    string stringDPI = (screenDPI + chromiumDPI).ToString(vAppCultureInfo);
                    launchArgument += " -force-device-scale-factor=" + stringDPI;

                    Debug.WriteLine("Chromium dpi scale factor: " + stringDPI);
                }

                //Launch the application
                appLaunched = await PrepareProcessLauncherWin32Async(appTitle, dataBindApp.PathExe, dataBindApp.PathLaunch, launchArgument, silent, allowMinimize, runAsAdmin, createNoWindow, launchKeyboard, false);

                //Update last launch date
                if (appLaunched)
                {
                    dataBindApp.LastLaunch = DateTime.Now.ToString(vAppCultureInfo);
                    //Debug.WriteLine("Updated last launch date: " + dataBindApp.LastLaunch);
                    JsonSaveApplications();
                }
            }
            catch { }
            return(appLaunched);
        }
예제 #4
0
        private static void TrayIconUpdateMonitorIndexes()
        {
            int dropMenuCount = ((ToolStripMenuItem)TrayMenuIcons.Items[0]).DropDownItems.Count;

            if (dropMenuCount > 0)
            {
                int count = 0;
                while (count < dropMenuCount)
                {
                    try
                    {
                        ((ToolStripMenuItem)TrayMenuIcons.Items[0]).DropDownItems.RemoveAt(0);
                    }
                    catch (Exception) { }

                    count++;
                }
            }

            for (int i = 0; i < DisplayMonitor.EnumerateMonitors().Length; i++)
            {
                ((ToolStripMenuItem)TrayMenuIcons.Items[0]).DropDownItems.Add($"#{i}",
                                                                              Resources.television__arrow.ToBitmap(), OnChangeMonitor);
            }
        }
        //Get single monitor information
        public static DisplayMonitor GetSingleMonitorDisplayConfig(int screenNumber)
        {
            try
            {
                //Query single monitor
                bool querySingleCheck = QuerySingleMonitorDisplayConfig(screenNumber, out DISPLAYCONFIG_PATH_INFO pathInfoTarget, out DISPLAYCONFIG_MODE_INFO modeInfoTarget);
                if (!querySingleCheck)
                {
                    Debug.WriteLine("Failed getting displayconfig monitor information.");
                    return(null);
                }

                //Create display monitor
                DisplayMonitor displayMonitorSettings = new DisplayMonitor();
                displayMonitorSettings.Identifier = screenNumber;

                //Get the screen name
                string monitorName = GetMonitorFriendlyName(pathInfoTarget.targetInfo.adapterId, pathInfoTarget.targetInfo.id);
                if (monitorName != "Unknown")
                {
                    monitorName = monitorName + " (" + pathInfoTarget.targetInfo.id + ")";
                }
                displayMonitorSettings.Name = monitorName;

                //Get the device path
                displayMonitorSettings.DevicePath = GetMonitorDevicePath(pathInfoTarget.targetInfo.adapterId, pathInfoTarget.targetInfo.id);

                //Get the screen dpi scale
                displayMonitorSettings.DpiScaleHorizontal = (float)GetMonitorDpiScale(pathInfoTarget.targetInfo.adapterId, pathInfoTarget.sourceInfo.id) / (float)100;
                displayMonitorSettings.DpiScaleVertical   = displayMonitorSettings.DpiScaleHorizontal;

                //Get the screen resolution
                displayMonitorSettings.WidthNative  = modeInfoTarget.sourceMode.position.y;
                displayMonitorSettings.HeightNative = modeInfoTarget.desktopImageInfo.PathSourceSize.x;
                displayMonitorSettings.WidthDpi     = (int)(displayMonitorSettings.WidthNative / displayMonitorSettings.DpiScaleHorizontal);
                displayMonitorSettings.HeightDpi    = (int)(displayMonitorSettings.HeightNative / displayMonitorSettings.DpiScaleVertical);

                //Get the screen refresh rate
                if (pathInfoTarget.targetInfo.refreshRate.Numerator != 0)
                {
                    displayMonitorSettings.RefreshRate = (int)(pathInfoTarget.targetInfo.refreshRate.Numerator / pathInfoTarget.targetInfo.refreshRate.Denominator);
                }
                else
                {
                    displayMonitorSettings.RefreshRate = 0;
                }

                //Get the screen hdr status
                displayMonitorSettings.HdrEnabled    = GetMonitorHdrStatus(pathInfoTarget.targetInfo.adapterId, pathInfoTarget.targetInfo.id);
                displayMonitorSettings.HdrWhiteLevel = GetMonitorHdrWhiteLevel(pathInfoTarget.targetInfo.adapterId, pathInfoTarget.targetInfo.id);

                return(displayMonitorSettings);
            }
            catch
            {
                Debug.WriteLine("Failed getting displayconfig monitor information.");
                return(null);
            }
        }
예제 #6
0
        private void ColorPrefixTextBox_TextChanged(object sender, EventArgs e)
        {
            var hexColors = ColorPrefixTextBox.Text;
            var intColors = DisplayMonitor.ColorsFromRgbs(hexColors);
            var values    = intColors.Select(x => DisplayMonitor.GetValue(x));

            ColorPrefixValueTextBox.Text = string.Join(",", values);
        }
예제 #7
0
파일: Program.cs 프로젝트: GKO95/Win32.EDID
        static void Main(string[] args)
        {
            //==============================================================
            // EXTRACTING MONITOR EDID
            //==============================================================
            var devices = new EnumerateDevices(DisplayMonitor.GetDeviceSelector());

            devices.EnumDisplay();
        }
예제 #8
0
        /// <summary>
        /// Gets display monitor information.
        /// </summary>
        /// <returns>Array of display monitor information</returns>
        public static async Task <DisplayItem[]> GetDisplayMonitorsAsync()
        {
            const string deviceInstanceIdKey = "System.Devices.DeviceInstanceId";

            try
            {
                var devices = await DeviceInformation.FindAllAsync(DisplayMonitor.GetDeviceSelector(), new[] { deviceInstanceIdKey });

                if (devices?.Any() == true)
                {
                    var items = new List <DisplayItem>(devices.Count);
                    foreach (var device in devices)
                    {
                        if (!device.Properties.TryGetValue(deviceInstanceIdKey, out object value))
                        {
                            continue;
                        }

                        var deviceInstanceId = value as string;
                        if (string.IsNullOrWhiteSpace(deviceInstanceId))
                        {
                            continue;
                        }

                        var displayMonitor = await DisplayMonitor.FromInterfaceIdAsync(device.Id);

                        //var displayMonitor = await DisplayMonitor.FromIdAsync(deviceInstanceId);
                        if (displayMonitor is null)
                        {
                            continue;
                        }

                        //Debug.WriteLine($"DeviceInstanceId: {deviceInstanceId}");
                        //Debug.WriteLine($"DeviceName: {device.Name}");
                        //Debug.WriteLine($"DisplayName: {displayMonitor.DisplayName}");
                        //Debug.WriteLine($"ConnectionKind: {displayMonitor.ConnectionKind}");
                        //Debug.WriteLine($"PhysicalConnector: {displayMonitor.PhysicalConnector}");
                        //Debug.WriteLine($"PhysicalSize: {GetDiagonal(displayMonitor.PhysicalSizeInInches):F1}");

                        items.Add(new DisplayItem(
                                      deviceInstanceId: deviceInstanceId,
                                      displayName: displayMonitor.DisplayName,
                                      isInternal: (displayMonitor.ConnectionKind == DisplayMonitorConnectionKind.Internal),
                                      connectionDescription: GetConnectionDescription(displayMonitor.ConnectionKind, displayMonitor.PhysicalConnector),
                                      physicalSize: GetDiagonal(displayMonitor.PhysicalSizeInInches)));
                    }
                    return(items.ToArray());
                }
            }
            catch (ArgumentException ax) when((uint)ax.HResult == ERROR_INVALID_PARAMETER)
            {
            }
            catch (Exception ex) when((uint)ex.HResult == ERROR_GEN_FAILURE)
            {
            }
            return(Array.Empty <DisplayItem>());
        }
예제 #9
0
        async Task vTaskLoop_MonitorTaskbar()
        {
            try
            {
                while (TaskCheckLoop(vTask_MonitorTaskbar))
                {
                    try
                    {
                        //Check taskbar visibility
                        AVTaskbarInformation taskbarInfo = new AVTaskbarInformation();

                        //Check if auto hide is enabled
                        if (taskbarInfo.IsAutoHide && taskbarInfo.IsVisible)
                        {
                            //Get the current active screen
                            int            monitorNumber          = Convert.ToInt32(Setting_Load(vConfigurationCtrlUI, "DisplayMonitor"));
                            DisplayMonitor displayMonitorSettings = GetSingleMonitorEnumDisplay(monitorNumber);

                            //Get the current taskbar size
                            int taskbarSize = 0;
                            if (taskbarInfo.Position == AppBarPosition.ABE_BOTTOM)
                            {
                                AVActions.ActionDispatcherInvoke(delegate
                                {
                                    try
                                    {
                                        //Update taskbar margin
                                        taskbarSize             = (int)(taskbarInfo.Bounds.Height / displayMonitorSettings.DpiScaleVertical);
                                        grid_Application.Margin = new Thickness(0, 0, 0, taskbarSize);
                                    }
                                    catch { }
                                });
                                continue;
                            }
                        }

                        //Reset taskbar margin
                        AVActions.ActionDispatcherInvoke(delegate
                        {
                            try
                            {
                                grid_Application.Margin = new Thickness(0);
                            }
                            catch { }
                        });
                    }
                    catch { }
                    finally
                    {
                        //Delay the loop task
                        await TaskDelayLoop(1000, vTask_MonitorTaskbar);
                    }
                }
            }
            catch { }
        }
예제 #10
0
        internal ExternalDisplayBrightnessController(MonitorInfo info, DisplayMonitor displayMonitor)
        {
            Maximum          = info.MaxValue;
            Minimum          = info.MinValue;
            currentValue     = info.CurrentValue;
            hPhysicalMonitor = info.Handle;
            Brightness       = currentValue;

            AssociatedDisplayMonitor = displayMonitor;
        }
예제 #11
0
        private static int GetMonitor(int monitorIndex)
        {
            var monitorArray = DisplayMonitor.EnumerateMonitors();

            if ((monitorArray.Length - 1) >= monitorIndex)
            {
                return((monitorArray[monitorIndex] != null) ? monitorIndex : 0);
            }
            return(0);
        }
예제 #12
0
        //Update the window position
        async Task UpdateWindowPosition(bool notifyApps, bool silent)
        {
            try
            {
                //Check if the application is maximized
                bool isMaximized = vAppMaximized;
                if (isMaximized)
                {
                    await AppSwitchScreenMode(false, true);
                }

                //Get the current active screen
                int            monitorNumber          = Convert.ToInt32(Setting_Load(vConfigurationCtrlUI, "DisplayMonitor"));
                DisplayMonitor displayMonitorSettings = GetSingleMonitorEnumDisplay(monitorNumber);

                //Get the current window size
                int windowWidth  = (int)(this.ActualWidth * displayMonitorSettings.DpiScaleHorizontal);
                int windowHeight = (int)(this.ActualHeight * displayMonitorSettings.DpiScaleVertical);

                //Check and resize the target window size
                if (windowWidth > displayMonitorSettings.WidthNative || windowHeight > displayMonitorSettings.HeightNative)
                {
                    windowWidth  = displayMonitorSettings.WidthNative;
                    windowHeight = displayMonitorSettings.HeightNative;
                    WindowResize(vInteropWindowHandle, windowWidth, windowHeight);
                }

                //Center the window on target screen
                int horizontalLeft = (int)(displayMonitorSettings.BoundsLeft + (displayMonitorSettings.WidthNative - windowWidth) / 2);
                int verticalTop    = (int)(displayMonitorSettings.BoundsTop + (displayMonitorSettings.HeightNative - windowHeight) / 2);
                WindowMove(vInteropWindowHandle, horizontalLeft, verticalTop);

                //Restore the previous screen mode
                if (isMaximized)
                {
                    await AppSwitchScreenMode(true, false);
                }

                //Notify apps the monitor changed
                if (notifyApps)
                {
                    await NotifyDirectXInputSettingChanged("DisplayMonitor");
                    await NotifyFpsOverlayerSettingChanged("DisplayMonitor");
                }

                //Show monitor change notification
                if (!silent)
                {
                    await Notification_Send_Status("MonitorNext", "Moved to monitor " + monitorNumber);
                }

                Debug.WriteLine("Moved the application to monitor: " + monitorNumber);
            }
            catch { }
        }
예제 #13
0
        public static IEnumerable <DeviceItem> EnumerateMonitorDevices()
        {
            var size    = (uint)Marshal.SizeOf <DISPLAY_DEVICE>();
            var display = new DISPLAY_DEVICE {
                cb = size
            };
            var monitor = new DISPLAY_DEVICE {
                cb = size
            };

            for (uint i = 0; EnumDisplayDevices(null, i, ref display, EDD_GET_DEVICE_INTERFACE_NAME); i++)
            {
                if (display.StateFlags.HasFlag(DISPLAY_DEVICE_FLAG.DISPLAY_DEVICE_MIRRORING_DRIVER))
                {
                    continue;
                }

                if (!TryGetDisplayIndex(display.DeviceName, out byte displayIndex))
                {
                    continue;
                }

                byte monitorIndex = 0;

                for (uint j = 0; EnumDisplayDevices(display.DeviceName, j, ref monitor, EDD_GET_DEVICE_INTERFACE_NAME); j++)
                {
                    var deviceInstanceId = GetDeviceInstanceId(monitor.DeviceID);
                    var isActive         = monitor.StateFlags.HasFlag(DISPLAY_DEVICE_FLAG.DISPLAY_DEVICE_ACTIVE);

                    //Debug.WriteLine($"DeviceId: {monitor.DeviceID}");
                    //Debug.WriteLine($"DeviceInstanceId: {deviceInstanceId}");
                    //Debug.WriteLine($"DeviceString: {monitor.DeviceString}");
                    //Debug.WriteLine($"IsActive {isActive}");

                    if (!isActive)
                    {
                        continue;
                    }

                    var displayMonitorTask = DisplayMonitor.FromIdAsync(deviceInstanceId).AsTask();
                    displayMonitorTask.Wait();
                    var displayMonitor = displayMonitorTask.Result;

                    yield return(new DeviceItem(
                                     deviceInstanceId: deviceInstanceId,
                                     description: monitor.DeviceString,
                                     displayIndex: displayIndex,
                                     monitorIndex: monitorIndex,
                                     friendlyName: displayMonitor.DisplayName));

                    monitorIndex++;
                }
            }
        }
        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
        {
            if (values.Any(o => o == DependencyProperty.UnsetValue || o == null))
            {
                return(null);
            }

            DisplayMonitor value          = values[0] as DisplayMonitor;
            DisplayMonitor preferredValue = values[1] as DisplayMonitor;

            return(value == preferredValue);
        }
예제 #15
0
 private void checkMonitor()
 {
     DisplayMonitor[] monitors = DisplayMonitor.EnumerateMonitors();
     if (c_monitor < monitors.Length)
     {
         if (monitors[c_monitor] != null)
         {
             return;
         }
     }
     c_monitor = 0;
 }
예제 #16
0
        public static VcpControl Vcp(this DisplayMonitor monitor)
        {
            if (AllVcp.ContainsKey(monitor))
            {
                return(AllVcp[monitor]);
            }

            VcpControl vcp = new VcpControl(monitor);

            AllVcp.Add(monitor, vcp);
            return(vcp);
        }
예제 #17
0
        private static async Task <List <DisplayMonitor> > GetMonitorInfosAsync()
        {
            var deviceInfos = await DeviceInformation.FindAllAsync(DisplayMonitor.GetDeviceSelector());

            List <DisplayMonitor> monitors = new();

            foreach (var deviceInfo in deviceInfos)
            {
                DisplayMonitor monitor = await DisplayMonitor.FromInterfaceIdAsync(deviceInfo.Id);

                monitors.Add(monitor);
            }
            return(monitors);
        }
예제 #18
0
            public async Task PopulateAsync()
            {
                System = GetSystem();

                var sw = new Stopwatch();

                var tasks = new[]
                {
                    GetTask(nameof(DeviceItems), () =>
                            DeviceItems = DeviceContext.EnumerateMonitorDevices().ToArray()),

                    GetTask(nameof(DisplayMonitorItems), async() =>
                    {
                        if (OsVersion.Is10Build17134OrGreater)
                        {
                            DisplayMonitorItems = await DisplayMonitor.GetDisplayMonitorsAsync();
                        }
                    }),

                    GetTask(nameof(DisplayConfigItems), () =>
                            DisplayConfigItems = DisplayConfig.EnumerateDisplayConfigs().ToArray()),

                    GetTask(nameof(InstalledItems), () =>
                            InstalledItems = DeviceInformation.EnumerateInstalledMonitors().ToArray()),

                    GetTask(nameof(PhysicalItems), () =>
                            PhysicalItems = DeviceContext.GetMonitorHandles().ToDictionary(
                                x => x,
                                x => MonitorConfiguration.EnumeratePhysicalMonitors(x.MonitorHandle, true)
                                .Select(x => new PhysicalItemPlus(x))
                                .ToArray())),

                    GetTask(nameof(DesktopItems), () =>
                            DesktopItems = MSMonitor.EnumerateDesktopMonitors().ToArray())
                };

                sw.Start();

                ElapsedTime = await Task.WhenAll(tasks);

                sw.Stop();

                Task <string> GetTask(string name, Action action) =>
                Task.Run(() =>
                {
                    action.Invoke();
                    var elapsed = sw.Elapsed;
                    return($@"{name,-14} -> {elapsed.ToString($@"{(elapsed.Minutes > 0 ? @"m\:" : string.Empty)}s\.fff")}");
                });
            }
예제 #19
0
        //Update the window position
        public void UpdateWindowPosition()
        {
            try
            {
                //Get the current active screen
                int            monitorNumber          = Convert.ToInt32(Setting_Load(vConfigurationCtrlUI, "DisplayMonitor"));
                DisplayMonitor displayMonitorSettings = GetSingleMonitorEnumDisplay(monitorNumber);

                //Move and resize the window
                WindowMove(vInteropWindowHandle, displayMonitorSettings.BoundsLeft, displayMonitorSettings.BoundsTop);
                WindowResize(vInteropWindowHandle, displayMonitorSettings.WidthNative, displayMonitorSettings.HeightNative);
            }
            catch { }
        }
예제 #20
0
 public override string ToString()
 {
     if (MonitorString == null)
     {
         try
         {
             DisplayMonitor monitor = Task.Run(async() => await GetMonitorInfoAsync()).Result;
             if (monitor != null && monitor.DisplayName.Length > 0)
             {
                 MonitorString = $"{monitor.DisplayName} - {monitor.DisplayAdapterTargetId}";
             }
             else
             {
                 string[] split = Id.Split('#', '&');
                 MonitorString = $"{split[1]} - {split[5][3..]}";
예제 #21
0
        public SetupForm()
        {
            InitializeComponent();

            // Automatically set the monitor index

            for (int i = 0; i < DisplayMonitor.EnumerateMonitors().Length; i++)
            {
                cbMonitorIndex.Items.Add(i);
            }

            LoadSettings();

            lblVersion.Text = Assembly.GetExecutingAssembly().GetName().Version.ToString();
        }
        private async Task <DisplayMonitor> GetMonitorInfoAsync()
        {
            var deviceInfos = await DeviceInformation.FindAllAsync(DisplayMonitor.GetDeviceSelector());

            foreach (var deviceInfo in deviceInfos)
            {
                if (deviceInfo.Id == Id)
                {
                    var monitor = await DisplayMonitor.FromInterfaceIdAsync(deviceInfo.Id);

                    return(monitor);
                }
            }
            return(null);
        }
예제 #23
0
        /// <summary>
        /// Gets display monitor information.
        /// </summary>
        /// <returns>Array of display monitor information</returns>
        public static async Task <DisplayItem[]> GetDisplayMonitorsAsync()
        {
            const string deviceInstanceIdKey = "System.Devices.DeviceInstanceId";

            try
            {
                var devices = await DeviceInformation.FindAllAsync(DisplayMonitor.GetDeviceSelector(), new[] { deviceInstanceIdKey });

                if (devices is { Count : > 0 })
                {
                    var items = new List <DisplayItem>(devices.Count);
                    foreach (var device in devices)
                    {
                        if (!device.Properties.TryGetValue(deviceInstanceIdKey, out object value))
                        {
                            continue;
                        }

                        var deviceInstanceId = value as string;
                        if (string.IsNullOrWhiteSpace(deviceInstanceId))
                        {
                            continue;
                        }

                        var displayMonitor = await DisplayMonitor.FromInterfaceIdAsync(device.Id);

                        //var displayMonitor = await DisplayMonitor.FromIdAsync(deviceInstanceId);
                        if (displayMonitor is null)
                        {
                            continue;
                        }

                        //Debug.WriteLine($"DeviceInstanceId: {deviceInstanceId}");
                        //Debug.WriteLine($"DisplayName: {displayMonitor.DisplayName}");
                        //Debug.WriteLine($"ConnectionKind: {displayMonitor.ConnectionKind}");
                        //Debug.WriteLine($"PhysicalConnector: {displayMonitor.PhysicalConnector}");
                        //Debug.WriteLine($"PhysicalSize: {GetDiagonal(displayMonitor.PhysicalSizeInInches):F1}");

                        items.Add(new DisplayItem(
                                      deviceInstanceId: deviceInstanceId,
                                      displayName: displayMonitor.DisplayName,
                                      isInternal: (displayMonitor.ConnectionKind == DisplayMonitorConnectionKind.Internal),
                                      connectionDescription: GetConnectionDescription(displayMonitor.ConnectionKind, displayMonitor.PhysicalConnector),
                                      physicalSize: GetDiagonal(displayMonitor.PhysicalSizeInInches)));
                    }
                    return(items.ToArray());
                }
            }
예제 #24
0
        public SetupForm()
        {
            LOG.Info("Instantiating SetupForm");
            InitializeComponent();

            // Automatically set the monitor index
            for (int i = 0; i < DisplayMonitor.EnumerateMonitors().Length; i++)
            {
                cbMonitorIndex.Items.Add(i);
            }

            LoadSettings();

            tbHelp.Text     = Resources.SetupFormHelp;
            lblVersion.Text = Assembly.GetExecutingAssembly().GetName().Version.ToString();
            LOG.Info("SetupForm Instantiated");
        }
예제 #25
0
파일: Program.cs 프로젝트: GKO95/Win32.EDID
        /*
         *  GET EACH DisplayMonitor OBJECT from the DeviceInformation of the device interface ID,
         *  then acquire its descriptor (in this case, EDID).
         */
        public async void EnumDisplay()
        {
            for (var index = 0; index < deviceList.Count; index++)
            {
                if (index != 0)
                {
                    Console.WriteLine();
                }

                DisplayMonitor display = await DisplayMonitor.FromInterfaceIdAsync(deviceList[index].Id);

                byte[] EDID = display.GetDescriptor(DisplayMonitorDescriptorKind.Edid);

                string hexBuffer = BitConverter.ToString(EDID).Replace("-", " ").ToLower();
                Console.WriteLine(string.Format("{0} : {1}", deviceList[index].Name, deviceList[index].Id));
                Console.Write(hexBuffer + "\n");
            }
        }
예제 #26
0
        static void TestParcel()
        {
            Console.WriteLine("This is an verification test for parcel to see if the values corresponds!");
            var dsp = new DisplayMonitor();

            Console.Write("The price in euro for the parcel is: ");

            priceRealEstate = Convert.ToDecimal(Console.ReadLine());

            Console.Write("The zone is (central, periphery): ");
            zone = Console.ReadLine();
            Console.Write("The cadastral number is: ");
            address = Console.ReadLine();

            var realEstate = new Parcel(priceRealEstate, zone, address);

            dsp.Message(realEstate, new DummyCalculator());
        }
예제 #27
0
        //Update the window position
        public void UpdateWindowPosition()
        {
            try
            {
                //Get the current active screen
                int            monitorNumber          = Convert.ToInt32(Setting_Load(vConfigurationCtrlUI, "DisplayMonitor"));
                DisplayMonitor displayMonitorSettings = GetSingleMonitorEnumDisplay(monitorNumber);

                //Get the current window size
                int windowWidth  = (int)(this.ActualWidth * displayMonitorSettings.DpiScaleHorizontal);
                int windowHeight = (int)(this.ActualHeight * displayMonitorSettings.DpiScaleVertical);

                //Move the window to bottom center
                int horizontalLeft = (int)(displayMonitorSettings.BoundsLeft + (displayMonitorSettings.WidthNative - windowWidth) / 2);
                int verticalTop    = (int)(displayMonitorSettings.BoundsTop + displayMonitorSettings.HeightNative - windowHeight);
                WindowMove(vInteropWindowHandle, horizontalLeft, verticalTop);
            }
            catch { }
        }
예제 #28
0
        //Move the keyboard window based on thumb movement
        public void MoveKeyboardWindow(int mouseHorizontal, int mouseVertical)
        {
            try
            {
                //Check the mouse movement position
                if (mouseHorizontal == 0 && mouseVertical == 0)
                {
                    return;
                }

                //Get the current window position
                WindowRectangle positionRect = new WindowRectangle();
                GetWindowRect(vInteropWindowHandle, ref positionRect);
                int moveLeft   = positionRect.Left + mouseHorizontal;
                int moveTop    = positionRect.Top + mouseVertical;
                int moveRight  = positionRect.Right + mouseHorizontal;
                int moveBottom = positionRect.Bottom + mouseVertical;

                //Get the current active screen
                int            monitorNumber          = Convert.ToInt32(Setting_Load(vConfigurationCtrlUI, "DisplayMonitor"));
                DisplayMonitor displayMonitorSettings = GetSingleMonitorEnumDisplay(monitorNumber);

                //Get the current window size
                int windowWidth  = (int)(this.ActualWidth * displayMonitorSettings.DpiScaleHorizontal);
                int windowHeight = (int)(this.ActualHeight * displayMonitorSettings.DpiScaleVertical);

                //Check if window leaves screen
                double screenEdgeLeft    = moveLeft + windowWidth;
                double screenLimitLeft   = displayMonitorSettings.BoundsLeft + 20;
                double screenEdgeTop     = moveTop + windowHeight;
                double screenLimitTop    = displayMonitorSettings.BoundsTop + 20;
                double screenEdgeRight   = moveRight - windowWidth;
                double screenLimitRight  = displayMonitorSettings.BoundsRight - 20;
                double screenEdgeBottom  = moveBottom - windowHeight;
                double screenLimitBottom = displayMonitorSettings.BoundsBottom - 20;
                if (screenEdgeLeft > screenLimitLeft && screenEdgeTop > screenLimitTop && screenEdgeRight < screenLimitRight && screenEdgeBottom < screenLimitBottom)
                {
                    WindowMove(vInteropWindowHandle, moveLeft, moveTop);
                }
            }
            catch { }
        }
예제 #29
0
        private static async Task <List <DeviceItemPlus> > GetMonitorDevicesAsync()
        {
            IDisplayItem[] displayItems = OsVersion.Is10Redstone4OrNewer
                                ? await DisplayMonitor.GetDisplayMonitorsAsync()
                                : DisplayConfig.EnumerateDisplayConfigs().ToArray();

            var deviceItems = DeviceContext.EnumerateMonitorDevices().ToArray();

            _ids = new HashSet <string>(deviceItems.Select(x => x.DeviceInstanceId));

            IEnumerable <DeviceItemPlus> Enumerate()
            {
                foreach (var deviceItem in deviceItems)
                {
                    var displayItem = displayItems.FirstOrDefault(x => string.Equals(deviceItem.DeviceInstanceId, x.DeviceInstanceId, StringComparison.OrdinalIgnoreCase));
                    if (displayItem is not null)
                    {
                        var isDescriptionNullOrWhiteSpace = string.IsNullOrWhiteSpace(deviceItem.Description);
                        if (isDescriptionNullOrWhiteSpace ||
                            Regex.IsMatch(deviceItem.Description, "^Generic (?:PnP|Non-PnP) Monitor$", RegexOptions.IgnoreCase))
                        {
                            if (!string.IsNullOrWhiteSpace(displayItem.DisplayName))
                            {
                                yield return(new DeviceItemPlus(deviceItem, displayItem.DisplayName, displayItem.IsInternal));

                                continue;
                            }
                            if (!isDescriptionNullOrWhiteSpace &&
                                !string.IsNullOrWhiteSpace(displayItem.ConnectionDescription))
                            {
                                yield return(new DeviceItemPlus(deviceItem, $"{deviceItem.Description} ({displayItem.ConnectionDescription})", displayItem.IsInternal));

                                continue;
                            }
                        }
                    }
                    yield return(new DeviceItemPlus(deviceItem));
                }
            }

            return(Enumerate().Where(x => !string.IsNullOrWhiteSpace(x.AlternateDescription)).ToList());
        }
예제 #30
0
        //[SupportedOSPlatform("Windows10.0.17134.0")]
        public async void UseDeviceApi()
        {
            if (OperatingSystem.IsWindowsVersionAtLeast(10, 0, 17134, 0))
            {
                var deviceInformations = await DeviceInformation.FindAllAsync(DisplayMonitor.GetDeviceSelector());

                foreach (DeviceInformation device in deviceInformations)
                {
                    DisplayMonitor displayMonitor = await DisplayMonitor.FromInterfaceIdAsync(device.Id);

                    // Print some info about the display monitor
                    var x = "DisplayName: " + displayMonitor.DisplayName;
                    var y = "ConnectionKind: " + displayMonitor.ConnectionKind;


                    if (OperatingSystem.IsWindowsVersionAtLeast(10, 0, 19041, 0))
                    {
                        var z = "IsDolbyVisionSupported: " + displayMonitor.IsDolbyVisionSupportedInHdrMode;
                    }
                }
            }
        }
예제 #31
0
        private async Task TestAsync()
        {
            var selector = DisplayMonitor.GetDeviceSelector();
            var infos    = await DeviceInformation.FindAllAsync(selector);

            var monitors = new List <DisplayMonitor>();

            foreach (var info in infos)
            {
                var monitor = await DisplayMonitor.FromInterfaceIdAsync(info.Id);

                monitors.Add(monitor);
            }

            var output = new List <string>();

            foreach (var monitor in monitors)
            {
                output.Add($"RawDpiX: {monitor.RawDpiX}    RawDpiY: {monitor.RawDpiY}    Width: {monitor.NativeResolutionInRawPixels.Width}    Height: {monitor.NativeResolutionInRawPixels.Height}");
            }
            MainListView.ItemsSource = output;
        }
예제 #32
0
		public override void Create( string name, int width, int height, bool fullScreen, NamedParameterList miscParams )
		{
			SWF.Control parentHWnd = null;
			SWF.Control externalHWnd = null;
            _fsaaType = D3D.MultisampleType.None;
            _fsaaQuality = 0;
		    fsaa = 0;
            vSync = false;
		    vSyncInterval = 1;
			var title = name;
		    var colorDepth = 32;
			var left = int.MaxValue; // Defaults to screen center
            var top = int.MaxValue; // Defaults to screen center
			var depthBuffer = true;
			var border = "";
			var outerSize = false;
            _useNVPerfHUD = false;
            var enableDoubleClick = false;
		    var monitorIndex = -1;

			if ( miscParams != null )
			{
			    object opt;
			    ;

				// left (x)
                if (miscParams.TryGetValue("left", out opt))
					left = Int32.Parse( opt.ToString() );

				// top (y)
                if (miscParams.TryGetValue("top", out opt))
					top = Int32.Parse( opt.ToString() );

				// Window title
                if (miscParams.TryGetValue("title", out opt))
					title = (string)opt;

				// parentWindowHandle		-> parentHWnd

                if (miscParams.TryGetValue("parentWindowHandle", out opt))
				{
                    // This is Axiom specific
					var handle = opt;
					var ptr = IntPtr.Zero;
                    if (handle.GetType() == typeof(IntPtr))
                    {
                        ptr = (IntPtr)handle;
                    }
                    else if (handle.GetType() == typeof(Int32))
                    {
                        ptr = new IntPtr( (int)handle );
                    }
                    else
                        throw new AxiomException( "unhandled parentWindowHandle type" );
					parentHWnd = SWF.Control.FromHandle( ptr );
				}

				// externalWindowHandle		-> externalHWnd
                if (miscParams.TryGetValue("externalWindowHandle", out opt))
				{
                    // This is Axiom specific
					var handle = opt;
					var ptr = IntPtr.Zero;
                    if (handle.GetType() == typeof(IntPtr))
                    {
                        ptr = (IntPtr)handle;
                    }
                    else if (handle.GetType() == typeof(Int32))
                    {
                        ptr = new IntPtr((int)handle);
                    }
                    else
                        throw new AxiomException("unhandled externalWindowHandle type");
					externalHWnd = SWF.Control.FromHandle( ptr );
				}

				// vsync	[parseBool]
                if (miscParams.TryGetValue("vsync", out opt))
					vSync = bool.Parse( opt.ToString() );

                // hidden	[parseBool]
                if (miscParams.TryGetValue("hidden", out opt))
                    _hidden = bool.Parse( opt.ToString() );

                // vsyncInterval	[parseUnsignedInt]
                if (miscParams.TryGetValue("vsyncInterval", out opt))
                    vSyncInterval = Int32.Parse( opt.ToString() );

				// displayFrequency
                if (miscParams.TryGetValue("displayFrequency", out opt))
					_displayFrequency = Int32.Parse( opt.ToString() );

				// colorDepth
                if (miscParams.TryGetValue("colorDepth", out opt))
					colorDepth = Int32.Parse( opt.ToString() );

				// depthBuffer [parseBool]
                if (miscParams.TryGetValue("depthBuffer", out opt))
					depthBuffer = bool.Parse( opt.ToString() );

				// FSAA type
                if (miscParams.TryGetValue("FSAA", out opt))
                    _fsaaType = (MultisampleType)opt;

				// FSAA quality
                if (miscParams.TryGetValue("FSAAQuality", out opt))
                    fsaaHint = opt.ToString();

				// window border style
                if (miscParams.TryGetValue("border", out opt))
                    border = ( (string)opt ).ToLower();

				// set outer dimensions?
                if (miscParams.TryGetValue("outerDimensions", out opt))
                    outerSize = bool.Parse( opt.ToString() );

				// NV perf HUD?
                if (miscParams.TryGetValue("useNVPerfHUD", out opt))
                    _useNVPerfHUD = bool.Parse( opt.ToString() );

                // sRGB?
                if (miscParams.TryGetValue("gamma", out opt))
                    hwGamma = bool.Parse(opt.ToString());

                // monitor index
                if (miscParams.TryGetValue("monitorIndex", out opt))
                    monitorIndex = Int32.Parse(opt.ToString());

                if (miscParams.TryGetValue("show", out opt))
                    _hidden = bool.Parse(opt.ToString());

                // enable double click messages
                if (miscParams.TryGetValue("enableDoubleClick", out opt))
                    enableDoubleClick = bool.Parse(opt.ToString());
			}

		    isFullScreen = fullScreen;

            // Destroy current window if any
			if ( hWnd != null )
			{
				Dispose();
			}

		    System.Drawing.Rectangle rc;
		    if ( externalHWnd == null )
		    {
		        WindowsExtendedStyle dwStyleEx = 0;
			    var hMonitor = IntPtr.Zero;

			    // If we specified which adapter we want to use - find it's monitor.
			    if ( monitorIndex != -1 )
			    {
			        var direct3D9 = D3DRenderSystem.Direct3D9;

			        for ( var i = 0; i < direct3D9.AdapterCount; ++i )
			        {
			            if ( i != monitorIndex )
			                continue;

			            hMonitor = direct3D9.GetAdapterMonitor( i );
			            break;
			        }
			    }

			    // If we didn't specified the adapter index, or if it didn't find it
			    if ( hMonitor == IntPtr.Zero )
			    {
			        // Fill in anchor point.
			        var windowAnchorPoint = new Point( left, top );

			        // Get the nearest monitor to this window.
			        hMonitor = DisplayMonitor.FromPoint( windowAnchorPoint, MonitorSearchFlags.DefaultToNearest ).Handle;
			    }

			    var monitorInfo = new DisplayMonitor( hMonitor );

			    // Update window style flags.
                fullscreenWinStyle = WindowStyles.WS_CLIPCHILDREN | WindowStyles.WS_POPUP;
                windowedWinStyle = WindowStyles.WS_CLIPCHILDREN;

			    if ( !_hidden )
			    {
                    fullscreenWinStyle |= WindowStyles.WS_VISIBLE;
                    windowedWinStyle |= WindowStyles.WS_VISIBLE;
			    }

			    if ( parentHWnd != null )
			    {
                    windowedWinStyle |= WindowStyles.WS_CHILD;
			    }
			    else
			    {
			        if ( border == "none" )
                        windowedWinStyle |= WindowStyles.WS_POPUP;
			        else if ( border == "fixed" )
                        windowedWinStyle |= WindowStyles.WS_OVERLAPPED | WindowStyles.WS_BORDER | WindowStyles.WS_CAPTION |
                                             WindowStyles.WS_SYSMENU | WindowStyles.WS_MINIMIZEBOX;
			        else
                        windowedWinStyle |= WindowStyles.WS_OVERLAPPEDWINDOW;
			    }

			    var winWidth = width;
			    var winHeight = height;

			    // No specified top left -> Center the window in the middle of the monitor
			    if ( left == int.MaxValue || top == int.MaxValue )
			    {
			        var screenw = monitorInfo.WorkingArea.Right - monitorInfo.WorkingArea.Left;
			        var screenh = monitorInfo.WorkingArea.Bottom - monitorInfo.WorkingArea.Top;

			        // clamp window dimensions to screen size
			        var outerw = ( winWidth < screenw ) ? winWidth : screenw;
			        var outerh = ( winHeight < screenh ) ? winHeight : screenh;

			        if ( left == int.MaxValue )
			            left = monitorInfo.WorkingArea.Left + ( screenw - outerw )/2;
			        else if ( monitorIndex != -1 )
			            left += monitorInfo.WorkingArea.Left;

			        if ( top == int.MaxValue )
			            top = monitorInfo.WorkingArea.Top + ( screenh - outerh )/2;
			        else if ( monitorIndex != -1 )
			            top += monitorInfo.WorkingArea.Top;
			    }
			    else if ( monitorIndex != -1 )
			    {
			        left += monitorInfo.WorkingArea.Left;
			        top += monitorInfo.WorkingArea.Top;
			    }

			    this.width = desiredWidth = width;
			    this.height = desiredHeight = height;
			    this.top = top;
			    this.left = left;


			    if ( fullScreen )
			    {
			        dwStyleEx |= WindowsExtendedStyle.WS_EX_TOPMOST;
			        this.top = monitorInfo.Bounds.Top;
			        this.left = monitorInfo.Bounds.Left;
			    }
			    else
			    {
			        AdjustWindow( width, height, ref winWidth, ref winHeight );

			        if ( !outerSize )
			        {

			            // Calculate window dimensions required
			            // to get the requested client area
			            rc = new System.Drawing.Rectangle( 0, 0, this.width, this.height );
			            AdjustWindowRect( ref rc, GetWindowStyle( fullScreen ), false );
			            this.width = rc.Right - rc.Left;
			            this.height = rc.Bottom - rc.Top;

			            // Clamp window rect to the nearest display monitor.
			            if ( this.left < monitorInfo.WorkingArea.Left )
			                this.left = monitorInfo.WorkingArea.Left;

			            if ( this.top < monitorInfo.WorkingArea.Top )
			                this.top = monitorInfo.WorkingArea.Top;

			            if ( winWidth > monitorInfo.WorkingArea.Right - this.left )
			                winWidth = monitorInfo.WorkingArea.Right - this.left;

			            if ( winHeight > monitorInfo.WorkingArea.Bottom - this.top )
			                winHeight = monitorInfo.WorkingArea.Bottom - this.top;
			        }
			    }

                WindowClassStyle classStyle = 0;
			    if ( enableDoubleClick )
                    classStyle |= WindowClassStyle.CS_DBLCLKS;


			    // Register the window class
			    // NB allow 4 bytes of window data for D3D9RenderWindow pointer
                /*
			    WNDCLASS wc = {
			                      classStyle, WindowEventUtilities::_WndProc, 0, 0, hInst,
			                      LoadIcon( 0, IDI_APPLICATION ), LoadCursor( NULL, IDC_ARROW ),
			                      (HBRUSH)GetStockObject( BLACK_BRUSH ), 0, "OgreD3D9Wnd"
			                  };
			    RegisterClass( &wc );

			    // Create our main window
			    // Pass pointer to self
			    _isExternal = false;

			    hWnd = CreateWindowEx( dwStyleEx, "OgreD3D9Wnd", title.c_str(), getWindowStyle( fullScreen ),
			                            mLeft, mTop, winWidth, winHeight, parentHWnd, 0, hInst, this );
                */

                var wnd = new DefaultForm(classStyle, dwStyleEx, title, GetWindowStyle(fullScreen),
                    this.left, this.top, winWidth, winHeight, parentHWnd);
		        hWnd = wnd;
                wnd.RenderWindow = this;
                WindowEventMonitor.Instance.RegisterWindow( this );
			}
			else
			{
			    hWnd = externalHWnd;
			    _isExternal = true;
			}

		    // top and left represent outer window coordinates
		    rc = new System.Drawing.Rectangle(hWnd.Location, hWnd.Size);

		    this.top = rc.Top;
		    this.left = rc.Left;
		    
            // width and height represent interior drawable area
		    rc = hWnd.ClientRectangle;
		   
		    this.width = rc.Right;
		    this.height = rc.Bottom;

		    this.name = name;
            depthBufferPoolId = depthBuffer ? PoolId.Default : PoolId.NoDepth;
		    this.depthBuffer = null;
		    this.colorDepth = colorDepth;


		    LogManager.Instance.Write("D3D9 : Created D3D9 Rendering Window '{0}' : {1}x{2}, {3}bpp",
                this.name, this.width, this.height, this.colorDepth);

		    active = true;
		    _isClosed = false;

		    IsHidden = _hidden;
		}