From fb0c5a8d072e3eca4fd952700de17aef890041c6 Mon Sep 17 00:00:00 2001 From: Nguyen Duy Date: Fri, 29 Mar 2024 23:27:09 +0700 Subject: [PATCH] add app source code --- app/App.config | 6 + app/App.xaml | 9 + app/App.xaml.cs | 105 +++++++ app/Components/Button.xaml | 53 ++++ app/Components/Button.xaml.cs | 23 ++ app/Components/CloseButton.xaml | 36 +++ app/Components/CloseButton.xaml.cs | 20 ++ app/Components/CustomPage.xaml | 96 ++++++ app/Components/CustomPage.xaml.cs | 98 ++++++ app/Components/DisplayItem.xaml | 55 ++++ app/Components/DisplayItem.xaml.cs | 205 ++++++++++++ app/Config.cs | 76 +++++ app/Device.cs | 448 +++++++++++++++++++++++++++ app/Display.cs | 411 ++++++++++++++++++++++++ app/Helper.cs | 79 +++++ app/MainWindow.xaml | 105 +++++++ app/MainWindow.xaml.cs | 173 +++++++++++ app/ParsecVDD.cs | 310 ++++++++++++++++++ app/ParsecVDisplay.csproj | 162 ++++++++++ app/Properties/App.manifest | 77 +++++ app/Properties/AssemblyInfo.cs | 55 ++++ app/Properties/Resources.Designer.cs | 71 +++++ app/Properties/Resources.resx | 117 +++++++ app/Properties/Settings.Designer.cs | 30 ++ app/Properties/Settings.settings | 7 + app/Resources/admin.png | Bin 0 -> 548 bytes app/Resources/background.png | Bin 0 -> 248018 bytes app/Resources/github.png | Bin 0 -> 689 bytes app/Resources/icon.ico | Bin 0 -> 32798 bytes app/Resources/settings.png | Bin 0 -> 357 bytes app/Resources/sync.png | Bin 0 -> 366 bytes app/Shadow.cs | 38 +++ app/Tray.cs | 84 +++++ app/setup/setup.iss | 64 ++++ 34 files changed, 3013 insertions(+) create mode 100644 app/App.config create mode 100644 app/App.xaml create mode 100644 app/App.xaml.cs create mode 100644 app/Components/Button.xaml create mode 100644 app/Components/Button.xaml.cs create mode 100644 app/Components/CloseButton.xaml create mode 100644 app/Components/CloseButton.xaml.cs create mode 100644 app/Components/CustomPage.xaml create mode 100644 app/Components/CustomPage.xaml.cs create mode 100644 app/Components/DisplayItem.xaml create mode 100644 app/Components/DisplayItem.xaml.cs create mode 100644 app/Config.cs create mode 100644 app/Device.cs create mode 100644 app/Display.cs create mode 100644 app/Helper.cs create mode 100644 app/MainWindow.xaml create mode 100644 app/MainWindow.xaml.cs create mode 100644 app/ParsecVDD.cs create mode 100644 app/ParsecVDisplay.csproj create mode 100644 app/Properties/App.manifest create mode 100644 app/Properties/AssemblyInfo.cs create mode 100644 app/Properties/Resources.Designer.cs create mode 100644 app/Properties/Resources.resx create mode 100644 app/Properties/Settings.Designer.cs create mode 100644 app/Properties/Settings.settings create mode 100644 app/Resources/admin.png create mode 100644 app/Resources/background.png create mode 100644 app/Resources/github.png create mode 100644 app/Resources/icon.ico create mode 100644 app/Resources/settings.png create mode 100644 app/Resources/sync.png create mode 100644 app/Shadow.cs create mode 100644 app/Tray.cs create mode 100644 app/setup/setup.iss diff --git a/app/App.config b/app/App.config new file mode 100644 index 0000000..8e15646 --- /dev/null +++ b/app/App.config @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/app/App.xaml b/app/App.xaml new file mode 100644 index 0000000..1e29147 --- /dev/null +++ b/app/App.xaml @@ -0,0 +1,9 @@ + + + + + diff --git a/app/App.xaml.cs b/app/App.xaml.cs new file mode 100644 index 0000000..0eefccb --- /dev/null +++ b/app/App.xaml.cs @@ -0,0 +1,105 @@ +using System; +using System.Threading.Tasks; +using System.Threading; +using System.Windows; +using System.Linq; +using System.Windows.Interop; +using System.Windows.Media; + +namespace ParsecVDisplay +{ + public partial class App : Application + { + const string ID = "QpHOX8IBUHBznGtqk9xm1"; + public const string NAME = "ParsecVDisplay"; + public const string VERSION = "0.45.0"; + + public static bool Silent { get; private set; } + + static App() + { + var displays = Display.GetAllDisplays(); + return; + } + + protected override void OnStartup(StartupEventArgs e) + { + if (e.Args.Length >= 2 && e.Args[0] == "-custom") + { + var modes = Display.ParseModes(e.Args[1]); + ParsecVDD.SetCustomDisplayModes(modes); + + Shutdown(); + return; + } + + Silent = e.Args.Contains("-silent"); + + var signal = new EventWaitHandle(false, + EventResetMode.AutoReset, ID, out var isOwned); + + if (!isOwned) + { + signal.Set(); + Shutdown(); + return; + } + + var status = ParsecVDD.QueryStatus(); + if (status != Device.Status.OK) + { + if (status == Device.Status.RESTART_REQUIRED) + { + MessageBox.Show("You must restart your PC to complete the driver setup.", + NAME, MessageBoxButton.OK, MessageBoxImage.Warning); + } + else if (status == Device.Status.DISABLED) + { + MessageBox.Show($"{ParsecVDD.ADAPTER} is disabled, please enable it.", + NAME, MessageBoxButton.OK, MessageBoxImage.Warning); + } + else if (status == Device.Status.NOT_INSTALLED) + { + MessageBox.Show("Please install the driver first.", + NAME, MessageBoxButton.OK, MessageBoxImage.Warning); + } + else + { + MessageBox.Show($"The driver is not OK, please check again. Current status: {status}.", + NAME, MessageBoxButton.OK, MessageBoxImage.Warning); + } + + Shutdown(); + return; + } + + if (ParsecVDD.Init() == false) + { + MessageBox.Show("Failed to obtain the device handle, please check the driver installation again.", + NAME, MessageBoxButton.OK, MessageBoxImage.Warning); + + Shutdown(); + return; + } + + Task.Run(() => + { + while (signal.WaitOne()) + { + Tray.ShowApp(); + } + }); + + base.OnStartup(e); + + // Disable GPU to prevent flickering when adding display + RenderOptions.ProcessRenderMode = RenderMode.SoftwareOnly; + } + + protected override void OnExit(ExitEventArgs e) + { + ParsecVDD.Uninit(); + base.OnExit(e); + } + } +} \ No newline at end of file diff --git a/app/Components/Button.xaml b/app/Components/Button.xaml new file mode 100644 index 0000000..5e43b8d --- /dev/null +++ b/app/Components/Button.xaml @@ -0,0 +1,53 @@ + + + + + + + + \ No newline at end of file diff --git a/app/Components/Button.xaml.cs b/app/Components/Button.xaml.cs new file mode 100644 index 0000000..3eb78c7 --- /dev/null +++ b/app/Components/Button.xaml.cs @@ -0,0 +1,23 @@ +using System; +using System.Windows; +using System.Windows.Controls; + +namespace ParsecVDisplay.Components +{ + public partial class Button : UserControl + { + public event EventHandler Click; + public object Children { get; set; } + + public Button() + { + InitializeComponent(); + DataContext = this; + } + + private void Button_Click(object sender, RoutedEventArgs e) + { + Click?.Invoke(sender, e); + } + } +} \ No newline at end of file diff --git a/app/Components/CloseButton.xaml b/app/Components/CloseButton.xaml new file mode 100644 index 0000000..6d51eb1 --- /dev/null +++ b/app/Components/CloseButton.xaml @@ -0,0 +1,36 @@ + + + \ No newline at end of file diff --git a/app/Components/CloseButton.xaml.cs b/app/Components/CloseButton.xaml.cs new file mode 100644 index 0000000..7173dee --- /dev/null +++ b/app/Components/CloseButton.xaml.cs @@ -0,0 +1,20 @@ +using System; +using System.Windows; +using System.Windows.Controls; + +namespace ParsecVDisplay.Components +{ + public partial class CloseButton : UserControl + { + public CloseButton() + { + InitializeComponent(); + } + + private void Button_Click(object sender, RoutedEventArgs e) + { + var window = Window.GetWindow(this); + window?.Close(); + } + } +} \ No newline at end of file diff --git a/app/Components/CustomPage.xaml b/app/Components/CustomPage.xaml new file mode 100644 index 0000000..72df497 --- /dev/null +++ b/app/Components/CustomPage.xaml @@ -0,0 +1,96 @@ + + + + \ No newline at end of file diff --git a/app/Components/CustomPage.xaml.cs b/app/Components/CustomPage.xaml.cs new file mode 100644 index 0000000..699ab31 --- /dev/null +++ b/app/Components/CustomPage.xaml.cs @@ -0,0 +1,98 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Media; + +namespace ParsecVDisplay.Components +{ + public partial class CustomPage : Page + { + TextBox[] TextBoxes; + + public CustomPage() + { + InitializeComponent(); + } + + private void ApplyChanges(object sender, EventArgs e) + { + var modes = new List(); + + for (int i = 0; i < 15; i += 3) + { + var tw = TextBoxes[i].Text; + var th = TextBoxes[i + 1].Text; + var thz = TextBoxes[i + 2].Text; + + if (int.TryParse(tw, out var width) + && int.TryParse(th, out var height) + && int.TryParse(thz, out var hz)) + { + // Check negative values & limit 8K resolution + if (width < 0 || width > 7680 || height < 0 || height > 4320 || hz < 0) + { + MessageBox.Show($"Found invalid value in slot {i / 3 + 1}.", + App.NAME, MessageBoxButton.OK, MessageBoxImage.Warning); + return; + } + else + { + modes.Add(new Display.Mode(width, height, hz)); + } + } + } + + if (modes.Count > 0) + { + if (Helper.IsAdmin()) + { + ParsecVDD.SetCustomDisplayModes(modes); + } + else + { + var args = $"-custom \"{Display.DumpModes(modes)}\""; + if (Helper.RunAdminTask(args) == false) + { + MessageBox.Show("Could not set custom resolutions, access denied!", + App.NAME, MessageBoxButton.OK, MessageBoxImage.Warning); + return; + } + } + } + + Window.GetWindow(this)?.Close(); + } + + private void Page_Loaded(object sender, RoutedEventArgs e) + { + TextBoxes = FindVisualChildren(this).ToArray(); + + var modes = ParsecVDD.GetCustomDisplayModes(); + + for (int i = 0, j = 0; i < 15 && j < modes.Count; i += 3, j++) + { + TextBoxes[i].Text = $"{modes[j].Width}"; + TextBoxes[i + 1].Text = $"{modes[j].Height}"; + TextBoxes[i + 2].Text = $"{modes[j].Hz}"; + } + } + + private void Page_Unloaded(object sender, RoutedEventArgs e) + { + } + + static IEnumerable FindVisualChildren(DependencyObject depObj) where T : DependencyObject + { + if (depObj == null) yield return (T)Enumerable.Empty(); + for (int i = 0; i < VisualTreeHelper.GetChildrenCount(depObj); i++) + { + DependencyObject ithChild = VisualTreeHelper.GetChild(depObj, i); + if (ithChild == null) continue; + if (ithChild is T t) yield return t; + foreach (T childOfChild in FindVisualChildren(ithChild)) yield return childOfChild; + } + } + } +} \ No newline at end of file diff --git a/app/Components/DisplayItem.xaml b/app/Components/DisplayItem.xaml new file mode 100644 index 0000000..05d438c --- /dev/null +++ b/app/Components/DisplayItem.xaml @@ -0,0 +1,55 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/Components/DisplayItem.xaml.cs b/app/Components/DisplayItem.xaml.cs new file mode 100644 index 0000000..172a7c6 --- /dev/null +++ b/app/Components/DisplayItem.xaml.cs @@ -0,0 +1,205 @@ +using System; +using System.IO; +using System.Threading.Tasks; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Input; + +namespace ParsecVDisplay.Components +{ + public partial class DisplayItem : UserControl + { + int Index = -1; + public bool Active { get; set; } = true; + public string DisplayNum { get; set; } = "1"; + public string DisplayName { get; set; } = "Display [1]"; + public string DisplayPath { get; set; } = "\\\\.\\DISPLAY1"; + public string DisplayMode { get; set; } = "1920 x 1080 @ 60 Hz"; + + Display Display; + Display.ModeSet SelectedResolution; + + public DisplayItem() + { + InitializeComponent(); + + xResolution.Items.Clear(); + xRefreshRate.Items.Clear(); + + DataContext = this; + } + + internal DisplayItem(Display display) : this() + { + Display = display; + + Active = display.Active; + Index = display.Address - 0x100; + + DisplayNum = $"{display.Identifier}"; + DisplayName = $"Display [{display.Identifier}]"; + DisplayPath = display.DeviceName; + + if (display.Active) + { + DisplayMode = display.CurrentMode.ToString(); + } + else + { + DisplayMode = "[offline]"; + } + } + + bool UpdateRefreshRates() + { + xRefreshRate.Items.Clear(); + var list = SelectedResolution.RefreshRates; + + bool hasDefault = false; + MenuItem _60hz = null; + + for (int i = 0; i < list.Count; i++) + { + int hz = list[i]; + + var mi = new MenuItem + { + Header = $"{hz} Hz", + IsCheckable = true, + IsChecked = Display.CurrentMode.Hz == hz, + }; + + if (hz == 60) _60hz = mi; + if (!hasDefault) hasDefault = mi.IsChecked; + + xRefreshRate.Items.Add(mi); + } + + if (!hasDefault && _60hz != null) + { + _60hz.IsChecked = true; + return true; + } + + return false; + } + + private void UserControl_MouseDown(object sender, MouseButtonEventArgs e) + { + e.Handled = true; + } + + private void UserControl_MouseUp(object sender, MouseButtonEventArgs e) + { + e.Handled = true; + ContextMenu.DataContext = this; + ContextMenu.IsOpen = true; + + if (Active && SelectedResolution == null) + { + foreach (var res in Display.SupportedResolutions) + { + bool @checked = Display.CurrentMode.Width == res.Width + && Display.CurrentMode.Height == res.Height; + + if (@checked) + SelectedResolution = res; + + xResolution.Items.Add(new MenuItem + { + IsCheckable = true, + IsChecked = @checked, + Header = $"{res.Width} × {res.Height}", + }); + } + + UpdateRefreshRates(); + + int oridentationIndex = (int)Display.CurrentOrientation; + (xOrientation.Items[oridentationIndex] as MenuItem).IsChecked = true; + } + } + + private void ChangeResolution(object sender, RoutedEventArgs e) + { + if (Active && e.OriginalSource != null) + { + for (int i = 0; i < xResolution.Items.Count; i++) + { + var item = xResolution.Items[i] as MenuItem; + if (item == e.OriginalSource) + { + item.IsChecked = true; + SelectedResolution = Display.SupportedResolutions[i]; + int hz = UpdateRefreshRates() ? 60 : Display.CurrentMode.Hz; + Display.ChangeMode(SelectedResolution.Width, SelectedResolution.Height, hz, null); + } + else + { + item.IsChecked = false; + } + } + } + } + + private void ChangeOrientation(object sender, RoutedEventArgs e) + { + if (Active && e.OriginalSource != null) + { + for (int i = 0; i < xOrientation.Items.Count; i++) + { + var item = xOrientation.Items[i] as MenuItem; + if (item == e.OriginalSource) + { + item.IsChecked = true; + var orientation = (Display.Orientation)i; + Display.ChangeMode(null, null, null, orientation); + } + else + { + item.IsChecked = false; + } + } + } + } + + private void ChangeRefreshRate(object sender, RoutedEventArgs e) + { + if (Active && e.OriginalSource != null) + { + for (int i = 0; i < xRefreshRate.Items.Count; i++) + { + var item = xRefreshRate.Items[i] as MenuItem; + if (item == e.OriginalSource) + { + item.IsChecked = true; + int hz = SelectedResolution.RefreshRates[i]; + Display.ChangeMode(null, null, hz, null); + } + else + { + item.IsChecked = false; + } + } + } + } + + private void TakeScreenshot(object sender, RoutedEventArgs e) + { + Task.Run(() => + { + var path = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".png"); + Display.TakeScreenshot(path); + Helper.ShellExec(path); + }); + } + + private void RemoveDisplay(object sender, RoutedEventArgs e) + { + if (Index != -1) + { + ParsecVDD.RemoveDisplay(Index); + } + } + } +} \ No newline at end of file diff --git a/app/Config.cs b/app/Config.cs new file mode 100644 index 0000000..3429a87 --- /dev/null +++ b/app/Config.cs @@ -0,0 +1,76 @@ +using System; +using System.Reflection; +using Microsoft.Win32; + +namespace ParsecVDisplay +{ + internal static class Config + { + static string REG_PATH => $"HKEY_CURRENT_USER\\SOFTWARE\\{App.NAME}"; + static string REG_STARTUP_PATH => @"SOFTWARE\Microsoft\Windows\CurrentVersion\Run"; + + public static int DisplayCount + { + get => GetInt(nameof(DisplayCount)); + set => SetInt(nameof(DisplayCount), value); + } + + public static bool FallbackDisplay + { + get => GetInt(nameof(FallbackDisplay)) != 0; + set => SetInt(nameof(FallbackDisplay), value ? 1 : 0); + } + + public static bool KeepScreenOn + { + get + { + bool enable = GetInt(nameof(KeepScreenOn)) != 0; + Helper.StayAwake(enable); + return enable; + } + set + { + SetInt(nameof(KeepScreenOn), value ? 1 : 0); + Helper.StayAwake(value); + } + } + + static int GetInt(string key, int @default = 0) + { + var value = Registry.GetValue(REG_PATH, key, null); + return value == null ? @default : Convert.ToInt32(value); + } + + static void SetInt(string key, int value) + { + Registry.SetValue(REG_PATH, key, value, RegistryValueKind.DWord); + } + + public static bool RunOnStartup + { + get + { + using (var key = Registry.CurrentUser.OpenSubKey(REG_STARTUP_PATH, false)) + { + return key.GetValue(App.NAME) != null; + } + } + set + { + using (var key = Registry.CurrentUser.OpenSubKey(REG_STARTUP_PATH, true)) + { + if (value) + { + var exePath = Assembly.GetExecutingAssembly().Location; + key.SetValue(App.NAME, $"\"{exePath}\" -silent", RegistryValueKind.String); + } + else + { + key.DeleteValue(App.NAME, false); + } + } + } + } + } +} \ No newline at end of file diff --git a/app/Device.cs b/app/Device.cs new file mode 100644 index 0000000..63a7de6 --- /dev/null +++ b/app/Device.cs @@ -0,0 +1,448 @@ +using System; +using System.Runtime.InteropServices; +using System.Text; + +namespace ParsecVDisplay +{ + internal static unsafe class Device + { + public enum Status + { + OK, + INACCESSIBLE, + UNKNOW, + UNKNOW_PROBLEM, + DISABLED, + DRIVER_ERROR, + RESTART_REQUIRED, + DISABLED_SERVICE, + NOT_INSTALLED + } + + public static Status QueryStatus(string guid, string devId) + { + var status = Status.INACCESSIBLE; + + var devInfoData = new Native.SP_DEVINFO_DATA(); + devInfoData.cbSize = sizeof(Native.SP_DEVINFO_DATA); + + var classGuid = Guid.Parse(guid); + var devInfo = Native.SetupDiGetClassDevsA(ref classGuid, null, null, Native.DIGCF_PRESENT); + + if (devInfo != Native.INVALID_HANDLE_VALUE) + { + bool foundProp = false; + uint deviceIndex = 0; + + do + { + if (!Native.SetupDiEnumDeviceInfo(devInfo, deviceIndex, &devInfoData)) + break; + + int requiredSize = 0; + Native.SetupDiGetDeviceRegistryPropertyA(devInfo, &devInfoData, + Native.SPDRP_HARDWAREID, null, null, 0, &requiredSize); + + if (requiredSize > 0) + { + uint regDataType = 0; + IntPtr propBuffer = Marshal.AllocHGlobal(requiredSize); + + if (Native.SetupDiGetDeviceRegistryPropertyA( + devInfo, + &devInfoData, + Native.SPDRP_HARDWAREID, + ®DataType, + (void*)propBuffer, + requiredSize, + &requiredSize)) + { + if (regDataType == Native.REG_SZ || regDataType == Native.REG_MULTI_SZ) + { + for (IntPtr cp = propBuffer; ; cp += Native.lstrlenA(cp) + 1) + { + if (cp == (IntPtr)(0) || *(byte*)cp == 0 || (ulong)cp >= (ulong)(propBuffer + requiredSize)) + { + status = Status.NOT_INSTALLED; + goto except; + } + + if (devId.Equals(Marshal.PtrToStringAnsi(cp))) + break; + } + + foundProp = true; + uint devStatus, devProblemNum; + + if (Native.CM_Get_DevNode_Status(&devStatus, &devProblemNum, devInfoData.DevInst, 0) != Native.CR_SUCCESS) + { + status = Status.NOT_INSTALLED; + goto except; + } + + if ((devStatus & (Native.DN_DRIVER_LOADED | Native.DN_STARTED)) != 0) + { + status = Status.OK; + } + else if ((devStatus & Native.DN_HAS_PROBLEM) != 0) + { + switch (devProblemNum) + { + case Native.CM_PROB_NEED_RESTART: + status = Status.RESTART_REQUIRED; + break; + case Native.CM_PROB_DISABLED: + case Native.CM_PROB_HARDWARE_DISABLED: + status = Status.DISABLED; + break; + case Native.CM_PROB_DISABLED_SERVICE: + status = Status.DISABLED_SERVICE; + break; + default: + if (devProblemNum == Native.CM_PROB_FAILED_POST_START) + status = Status.DRIVER_ERROR; + else + status = Status.UNKNOW_PROBLEM; + break; + } + } + else + { + status = Status.UNKNOW; + } + } + } + + except: + Marshal.FreeHGlobal(propBuffer); + } + + ++deviceIndex; + } while (!foundProp); + + if (!foundProp && Marshal.GetLastWin32Error() != 0) + status = Status.NOT_INSTALLED; + + Native.SetupDiDestroyDeviceInfoList(devInfo); + } + + return status; + } + + public static bool OpenHandle(string guid, out IntPtr handle) + { + handle = IntPtr.Zero; + + var interfaceGuid = Guid.Parse(guid); + var devInfo = Native.SetupDiGetClassDevsA(ref interfaceGuid, + null, null, Native.DIGCF_PRESENT | Native.DIGCF_DEVICEINTERFACE); + + if (devInfo != Native.INVALID_HANDLE_VALUE) + { + var devInterface = new Native.SP_DEVICE_INTERFACE_DATA(); + devInterface.cbSize = sizeof(Native.SP_DEVICE_INTERFACE_DATA); + + for (uint i = 0; Native.SetupDiEnumDeviceInterfaces(devInfo, null, ref interfaceGuid, i, &devInterface); ++i) + { + int detailSize = 0; + Native.SetupDiGetDeviceInterfaceDetailA(devInfo, &devInterface, null, 0, &detailSize, null); + + var detail = (Native.SP_DEVICE_INTERFACE_DETAIL_DATA_A*)Marshal.AllocHGlobal(detailSize); + detail->cbSize = sizeof(Native.SP_DEVICE_INTERFACE_DETAIL_DATA_A); + + if (Native.SetupDiGetDeviceInterfaceDetailA(devInfo, &devInterface, detail, detailSize, &detailSize, null)) + { + handle = Native.CreateFileA(&detail->DevicePath, + Native.GENERIC_READ | Native.GENERIC_WRITE, + Native.FILE_SHARE_READ | Native.FILE_SHARE_WRITE, + null, + Native.OPEN_EXISTING, + Native.FILE_ATTRIBUTE_NORMAL | Native.FILE_FLAG_NO_BUFFERING | Native.FILE_FLAG_OVERLAPPED | Native.FILE_FLAG_WRITE_THROUGH, + null); + + if (handle != IntPtr.Zero && handle != Native.INVALID_HANDLE_VALUE) + break; + } + + Marshal.FreeHGlobal((IntPtr)detail); + } + + Native.SetupDiDestroyDeviceInfoList(devInfo); + } + + return handle != IntPtr.Zero + && handle != Native.INVALID_HANDLE_VALUE; + } + + public static void CloseHandle(IntPtr handle) + { + if (handle != IntPtr.Zero && handle != Native.INVALID_HANDLE_VALUE) + { + Native.CloseHandle(handle); + } + } + + public static string GetDeviceDescription(uint devInst) + { + uint propType; + int length = 128 * sizeof(ushort); + var buffer = stackalloc byte[length]; + + Native.CM_Get_DevNode_PropertyW(devInst, + ref Native.DEVPROPKEY.Device_DeviceDesc, &propType, buffer, &length, 0); + + return Marshal.PtrToStringUni((IntPtr)buffer); + } + + public static DateTime GetDeviceLastArrival(uint devInst) + { + uint propType; + long lastArrival; + int bufferLength = sizeof(long); + + Native.CM_Get_DevNode_PropertyW(devInst, + ref Native.DEVPROPKEY.Device_LastArrivalDate, &propType, &lastArrival, &bufferLength, 0); + + return DateTime.FromFileTime(lastArrival); + } + + public static bool GetParentDeviceInstance(uint devInst, out uint parentInst, out string parentId) + { + if (Native.CM_Get_Parent(out parentInst, devInst, 0) == 0) + { + byte[] idBuffer = new byte[Native.MAX_DEVICE_ID_LEN]; + Native.CM_Get_Device_IDA(parentInst, idBuffer, idBuffer.Length, 0); + + parentId = Encoding.ASCII.GetString(idBuffer).TrimEnd('\0'); + return true; + } + + parentInst = 0; + parentId = string.Empty; + return false; + } + + public static bool GetDeviceInstance(string deviceId, out uint devInst) + { + return Native.CM_Locate_DevNodeA(out devInst, deviceId, 0) == 0; + } + + static class Native + { + public const int MAX_DEVICE_ID_LEN = 200; + public static readonly IntPtr INVALID_HANDLE_VALUE = (IntPtr)(-1); + + public const uint GENERIC_READ = 0x80000000; + public const uint GENERIC_WRITE = 0x40000000; + + public const uint FILE_SHARE_READ = 0x1; + public const uint FILE_SHARE_WRITE = 0x2; + + public const uint OPEN_EXISTING = 3; + + public const uint FILE_ATTRIBUTE_NORMAL = 0x00000080; + public const uint FILE_FLAG_NO_BUFFERING = 0x20000000; + public const uint FILE_FLAG_OVERLAPPED = 0x40000000; + public const uint FILE_FLAG_WRITE_THROUGH = 0x80000000; + + public const uint DIGCF_PRESENT = 0x2; + public const uint DIGCF_DEVICEINTERFACE = 0x10; + + public const uint SPDRP_HARDWAREID = 0x1; + + public const uint REG_SZ = 1; + public const uint REG_MULTI_SZ = 7; + + public const uint CR_SUCCESS = 0; + + public const uint CM_PROB_NEED_RESTART = 0x0000000E; // requires restart + public const uint CM_PROB_DISABLED = 0x00000016; // devinst is disabled + public const uint CM_PROB_HARDWARE_DISABLED = 0x0000001D; // device disabled + public const uint CM_PROB_DISABLED_SERVICE = 0x00000020; // service's Start = 4 + public const uint CM_PROB_FAILED_POST_START = 0x0000002B; // The drivers set the device state to failed + + public const uint DN_DRIVER_LOADED = 0x00000002; // Has Register_Device_Driver + public const uint DN_STARTED = 0x00000008; // Is currently configured + public const uint DN_HAS_PROBLEM = 0x00000400; // Need device installer + + public static bool IsValidHandle(IntPtr handle) + { + return handle != IntPtr.Zero + && handle != (IntPtr)(-1); + } + + [DllImport("kernel32.dll", CallingConvention = CallingConvention.Cdecl)] + public static extern int lstrlenA( + IntPtr lpString); + + [DllImport("kernel32.dll")] + public static extern IntPtr CreateFileA( + char* lpFileName, + uint dwDesiredAccess, + uint dwShareMode, + void* lpSecurityAttributes, + uint dwCreationDisposition, + uint dwFlagsAndAttributes, + void* hTemplateFile); + + [DllImport("kernel32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool CloseHandle(IntPtr handle); + + [DllImport("kernel32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool DeviceIoControl( + IntPtr device, uint code, + void* lpInBuffer, int nInBufferSize, + void* lpOutBuffer, int nOutBufferSize, + IntPtr lpBytesReturned, + ref OVERLAPPED lpOverlapped + ); + + [DllImport("kernel32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool GetOverlappedResult( + IntPtr handle, + ref OVERLAPPED lpOverlapped, + out uint lpNumberOfBytesTransferred, + [MarshalAs(UnmanagedType.Bool)] bool bWait + ); + + [StructLayout(LayoutKind.Sequential)] + public struct OVERLAPPED + { + public IntPtr Internal; + public IntPtr InternalHigh; + public IntPtr Pointer; + public IntPtr hEvent; + } + + [StructLayout(LayoutKind.Sequential)] + public struct RECT + { + public int left; + public int top; + public int right; + public int bottom; + } + + [StructLayout(LayoutKind.Sequential)] + public struct SP_DEVICE_INTERFACE_DATA + { + public int cbSize; + public Guid InterfaceClassGuid; + public uint Flags; + IntPtr _Reserved; + } + + [StructLayout(LayoutKind.Sequential)] + public struct SP_DEVINFO_DATA + { + public int cbSize; + public Guid ClassGuid; + public uint DevInst; + IntPtr _Reserved; + } + + [StructLayout(LayoutKind.Sequential)] + public struct SP_DEVICE_INTERFACE_DETAIL_DATA_A + { + public int cbSize; + public char DevicePath; + } + + [DllImport("setupapi.dll")] + public static extern IntPtr SetupDiGetClassDevsA( + ref Guid ClassGuid, + void* Enumerator, + void* hwndParent, + uint Flags); + + [DllImport("setupapi.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool SetupDiEnumDeviceInterfaces( + IntPtr DeviceInfoSet, + SP_DEVINFO_DATA* DeviceInfoData, + ref Guid InterfaceClassGuid, + uint MemberIndex, + SP_DEVICE_INTERFACE_DATA* DeviceInterfaceData); + + [DllImport("setupapi.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool SetupDiGetDeviceInterfaceDetailA( + IntPtr DeviceInfoSet, + SP_DEVICE_INTERFACE_DATA* DeviceInterfaceData, + void* DeviceInterfaceDetailData, + int DeviceInterfaceDetailDataSize, + int* RequiredSize, + SP_DEVINFO_DATA* DeviceInfoData); + + [DllImport("setupapi.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool SetupDiDestroyDeviceInfoList( + IntPtr DeviceInfoSet); + + [DllImport("setupapi.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool SetupDiEnumDeviceInfo( + IntPtr DeviceInfoSet, + uint MemberIndex, + SP_DEVINFO_DATA* DeviceInfoData); + + [DllImport("setupapi.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool SetupDiGetDeviceRegistryPropertyA( + IntPtr DeviceInfoSet, + SP_DEVINFO_DATA* DeviceInfoData, + uint Property, + uint* PropertyRegDataType, + void* PropertyBuffer, + int PropertyBufferSize, + int* RequiredSize); + + [DllImport("setupapi.dll")] + public static extern uint CM_Get_DevNode_Status( + uint* pulStatus, + uint* pulProblemNumber, + uint dnDevInst, + uint ulFlags); + + [DllImport("setupapi.dll")] + public static extern uint CM_Get_Parent(out uint pdnDevInst, uint dnDevInst, uint ulFlags); + + [DllImport("setupapi.dll")] + public static extern uint CM_Get_Device_IDA(uint dnDevInst, byte[] Buffer, int BufferLen, uint ulFlags); + + [StructLayout(LayoutKind.Sequential)] + public struct DEVPROPKEY + { + public Guid fmtid; + public uint pid; + + public static DEVPROPKEY Device_LastArrivalDate = new DEVPROPKEY + { + fmtid = Guid.Parse("{83DA6326-97A6-4088-9453-A1923F573B29}"), + pid = 102, + }; + + public static DEVPROPKEY Device_DeviceDesc = new DEVPROPKEY + { + fmtid = Guid.Parse("{A45C254E-DF1C-4EFD-8020-67D146A850E0}"), + pid = 2 + }; + } + + [DllImport("CfgMgr32.dll")] + public static extern uint CM_Get_DevNode_PropertyW( + uint dnDevInst, + ref DEVPROPKEY PropertyKey, + uint* PropertyType, + void* PropertyBuffer, + int* PropertyBufferSize, + uint ulFlags); + + [DllImport("CfgMgr32.dll", CharSet = CharSet.Ansi)] + public static extern uint CM_Locate_DevNodeA(out uint devInst, string deviceId, uint flags); + } + } +} \ No newline at end of file diff --git a/app/Display.cs b/app/Display.cs new file mode 100644 index 0000000..521971e --- /dev/null +++ b/app/Display.cs @@ -0,0 +1,411 @@ +using System; +using System.Collections.Generic; +using System.Drawing; +using System.Globalization; +using System.Linq; +using System.Runtime.InteropServices; +using Microsoft.Win32; + +namespace ParsecVDisplay +{ + internal class Display + { + public enum Orientation + { + Angle0 = 0, // landscape + Angle90, // portrait + Angle180, // landscape (flipped) + Angle270 // portrait (flipped) + } + + public class Mode + { + public int Width; + public int Height; + public int Hz; + + public Mode() + { + } + + public Mode(int width, int height, int hz) + { + Width = width; + Height = height; + Hz = hz; + } + + public Mode(ulong bits) + { + Width = unchecked((ushort)bits); + Height = unchecked((ushort)(bits >> 16)); + Hz = unchecked((ushort)(bits >> 32)); + } + + public ulong Bits => (uint)(Width & 0xFFFF) + | ((ulong)(Height & 0xFFFF) << 16) + | ((ulong)(Hz & 0xFFFF) << 32); + + public string Resolution => $"{Width} × {Height}"; + public string RefreshRate => $"{Hz} Hz"; + public override string ToString() => $"{Resolution} @ {RefreshRate}"; + } + + public class ModeSet + { + public int Width; + public int Height; + public List RefreshRates; + } + + public bool Active; + public int Identifier; + public int CloneOf; + public int Address; + public DateTime LastArrival; + + public string Adapter; + public string AdapterInstance; + public DateTime AdapterArrival; + + public string DeviceName; + public string DisplayName; + + public Mode CurrentMode; + public Orientation CurrentOrientation; + public List ModeList; + public List SupportedResolutions; + + Display() + { + ModeList = new List(); + CurrentOrientation = Orientation.Angle0; + SupportedResolutions = new List(); + } + + public override string ToString() + { + var str = $"[{Identifier}] {DeviceName} ({DisplayName}#{Address})"; + if (CloneOf > 0 && CloneOf < Identifier) str += $" (clone of [{CloneOf}])"; + return str; + } + + void FetchAllModes() + { + var devMode = new Native.DEVMODE(); + devMode.dmSize = (short)Marshal.SizeOf(typeof(Native.DEVMODE)); + + var set = new Dictionary>(); + + for (int num = -1; Native.EnumDisplaySettings(DeviceName, num, ref devMode); num++) + { + var mode = new Mode + { + Width = devMode.dmPelsWidth, + Height = devMode.dmPelsHeight, + Hz = devMode.dmDisplayFrequency, + }; + + if (num == -1) + { + CurrentMode = mode; + CurrentOrientation = devMode.dmDisplayOrientation; + } + else + { + ModeList.Add(mode); + + mode.Hz = 0; + if (set.TryGetValue(mode.Bits, out var rrs)) + { + rrs.Add(devMode.dmDisplayFrequency); + } + else + { + set[mode.Bits] = new HashSet { devMode.dmDisplayFrequency }; + } + } + } + + foreach (var kv in set) + { + var mode = new Mode(kv.Key); + var rrs = kv.Value.ToList(); + rrs.Sort((a, b) => a - b); + + SupportedResolutions.Add(new ModeSet + { + Width = mode.Width, + Height = mode.Height, + RefreshRates = rrs, + }); + } + + SupportedResolutions.Sort((a, b) + => b.Width == a.Width ? (b.Height - a.Height) : (b.Width - a.Width)); + } + + public bool ChangeMode(int? width, int? height, int? hz, Orientation? orientation) + { + var mode = new Native.DEVMODE(); + mode.dmSize = (short)Marshal.SizeOf(typeof(Native.DEVMODE)); + + if (Native.EnumDisplaySettings(DeviceName, -1, ref mode)) + { + if (width.HasValue) mode.dmPelsWidth = width.Value; + if (height.HasValue) mode.dmPelsHeight = height.Value; + if (hz.HasValue) mode.dmDisplayFrequency = hz.Value; + + if (orientation.HasValue) + { + var newDO = orientation.Value; + mode.dmDisplayOrientation = newDO; + + if (((int)newDO + (int)CurrentOrientation) % 2 != 0) + { + int t = mode.dmPelsWidth; + mode.dmPelsWidth = mode.dmPelsHeight; + mode.dmPelsHeight = t; + } + } + + return Native.ChangeDisplaySettingsEx(DeviceName, + ref mode, IntPtr.Zero, 1, IntPtr.Zero) == 0; + } + + return false; + } + + public void TakeScreenshot(string saveFile) + { + int width = CurrentMode.Width; + int height = CurrentMode.Height; + + using (var bmp = new Bitmap(width, height)) + using (var gfx = Graphics.FromImage(bmp)) + { + var hdc = Native.CreateDC(IntPtr.Zero, DeviceName, IntPtr.Zero, IntPtr.Zero); + + var dstHdc = gfx.GetHdc(); + Native.BitBlt(dstHdc, 0, 0, width, height, hdc, 0, 0, 0x00CC0020); + gfx.ReleaseHdc(dstHdc); + + bmp.Save(saveFile, System.Drawing.Imaging.ImageFormat.Png); + Native.DeleteDC(hdc); + } + } + + public static string DumpModes(List modes) + { + return string.Join(",", modes.Select(m => m.Bits.ToString("x"))); + } + + public static List ParseModes(string modes) + { + var list = new List(); + var tokens = modes.Trim().Split(','); + foreach (var mode in tokens) + if (ulong.TryParse(mode, NumberStyles.HexNumber, null, out var bits)) + list.Add(new Mode(bits)); + + return list; + } + + public static List GetAllDisplays() + { + var displayMap = new Dictionary(StringComparer.OrdinalIgnoreCase); + var cloneGroups = new List>(); + + var paths = GetDisplayPaths(); + + var dd = new Native.DISPLAY_DEVICE(); + dd.cb = Marshal.SizeOf(typeof(Native.DISPLAY_DEVICE)); + + for (int i = 0; Native.EnumDisplayDevices(null, i, ref dd, 0); i++) + { + Display prevActiveDisplay = null; + + var dd2 = new Native.DISPLAY_DEVICE(); + dd2.cb = Marshal.SizeOf(typeof(Native.DISPLAY_DEVICE)); + + for (int j = 0; Native.EnumDisplayDevices(dd.DeviceName, j, ref dd2, Native.EDD_GET_DEVICE_INTERFACE_NAME); j++) + { + if ((dd2.StateFlags & Native.DISPLAY_DEVICE_ATTACHED) == 0) + continue; + + var pathIdx = paths.FindIndex(p => dd2.DeviceID.Contains(p.Replace('\\', '#'))); + if (pathIdx < 0) continue; + + if (!displayMap.ContainsKey(paths[pathIdx])) + { + var display = new Display + { + Active = (dd2.StateFlags & Native.DISPLAY_DEVICE_ACTIVE) != 0, + Address = ParseDisplayAddress(paths[pathIdx]), + DeviceName = dd.DeviceName, + DisplayName = ParseDisplayCode(dd2.DeviceID), + }; + + if (display.Active) + { + if (prevActiveDisplay == null) + { + prevActiveDisplay = display; + } + else + { + cloneGroups.Add(new Tuple(prevActiveDisplay, display)); + } + + display.FetchAllModes(); + } + + Device.GetDeviceInstance(paths[pathIdx], out uint devInst); + display.LastArrival = Device.GetDeviceLastArrival(devInst); + + Device.GetParentDeviceInstance(devInst, out uint parentInst, out display.AdapterInstance); + display.Adapter = Device.GetDeviceDescription(parentInst); + display.AdapterArrival = Device.GetDeviceLastArrival(parentInst); + + displayMap.Add(paths[pathIdx], display); + paths.RemoveAt(pathIdx); + } + } + } + + var displays = displayMap.Values.ToList(); + + // Sort displays by adapter arrival time + displays.Sort((a, b) => + { + if (a.AdapterInstance == b.AdapterInstance) + return a.LastArrival.CompareTo(b.LastArrival); + return a.AdapterArrival.CompareTo(b.AdapterArrival); + }); + + // Fill display identifier + for (int i = 0; i < displays.Count; i++) + displays[i].Identifier = i + 1; + + // Fill clone of identifier + foreach (var group in cloneGroups) + { + group.Item1.CloneOf = group.Item2.Identifier; + group.Item2.CloneOf = group.Item1.Identifier; + } + + cloneGroups.Clear(); + return displays; + } + + static List GetDisplayPaths() + { + using (var key = Registry.LocalMachine.OpenSubKey(@"SYSTEM\CurrentControlSet\Services\monitor\Enum", false)) + { + var paths = new List(); + int count = Convert.ToInt32(key.GetValue("Count", 0)); + + for (int i = 0; i < count; ++i) + { + var path = key.GetValue($"{i}"); + paths.Add(Convert.ToString(path)); + } + + return paths; + } + } + + static int ParseDisplayAddress(string path) + { + var index = path.LastIndexOf("uid", StringComparison.OrdinalIgnoreCase); + int.TryParse(path.Substring(index + 3), out var address); + return address; + } + + static string ParseDisplayCode(string id) + { + var tokens = id.Split('#'); + return tokens.Length >= 2 ? tokens[1] : tokens[0]; + } + + static class Native + { + public const uint EDD_GET_DEVICE_INTERFACE_NAME = 0x1; + public const uint DISPLAY_DEVICE_ACTIVE = 0x1; + public const uint DISPLAY_DEVICE_ATTACHED = 0x2; + + [DllImport("user32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool EnumDisplayDevices(string lpDevice, int iDevNum, ref DISPLAY_DEVICE lpDisplayDevice, uint dwFlags); + + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)] + public struct DISPLAY_DEVICE + { + public int cb; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)] + public string DeviceName; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)] + public string DeviceString; + public uint StateFlags; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)] + public string DeviceID; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)] + public string DeviceKey; + } + + [DllImport("user32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool EnumDisplaySettings(string deviceName, int modeNum, ref DEVMODE devMode); + + [DllImport("user32.dll")] + public static extern int ChangeDisplaySettingsEx(string lpszDeviceName, ref DEVMODE lpDevMode, + IntPtr hwnd, uint dwflags, IntPtr lParam); + + [StructLayout(LayoutKind.Sequential)] + public struct DEVMODE + { + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)] + public string dmDeviceName; + public short dmSpecVersion; + public short dmDriverVersion; + public short dmSize; + public short dmDriverExtra; + public int dmFields; + public int dmPositionX; + public int dmPositionY; + public Orientation dmDisplayOrientation; + public int dmDisplayFixedOutput; + public short dmColor; + public short dmDuplex; + public short dmYResolution; + public short dmTTOption; + public short dmCollate; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)] + public string dmFormName; + public short dmLogPixels; + public int dmBitsPerPel; + public int dmPelsWidth; + public int dmPelsHeight; + public int dmDisplayFlags; + public int dmDisplayFrequency; + public int dmICMMethod; + public int dmICMIntent; + public int dmMediaType; + public int dmDitherType; + public int dmReserved1; + public int dmReserved2; + public int dmPanningWidth; + public int dmPanningHeight; + } + + [DllImport("gdi32.dll")] + public static extern IntPtr CreateDC(IntPtr pwszDriver, string pwszDevice, IntPtr pszPort, IntPtr devmode); + + [DllImport("gdi32.dll")] + public static extern int BitBlt(IntPtr hdcDest, int nXDest, int nYDest, int nWidth, int nHeight, IntPtr hdcSrc, int nXSrc, int nYSrc, int rasterOperation); + + [DllImport("gdi32.dll")] + public static extern int DeleteDC(IntPtr hdc); + } + } +} \ No newline at end of file diff --git a/app/Helper.cs b/app/Helper.cs new file mode 100644 index 0000000..5b56f80 --- /dev/null +++ b/app/Helper.cs @@ -0,0 +1,79 @@ +using System; +using System.Diagnostics; +using System.IO; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Security.Principal; + +namespace ParsecVDisplay +{ + internal static class Helper + { + public static bool ShellExec(string file, string args = "", string cwd = null, bool admin = false) + { + try + { + var a = Assembly.GetAssembly(typeof(Process)); + var _p = a.GetType("System.Diagnostics.Process"); + var _psi = a.GetType("System.Diagnostics.ProcessStartInfo"); + + var psi = Activator.CreateInstance(_psi); + _psi.GetProperty("FileName").SetValue(psi, file); + _psi.GetProperty("UseShellExecute").SetValue(psi, true); + + if (!string.IsNullOrEmpty(args)) + _psi.GetProperty("Arguments").SetValue(psi, args); + if (!string.IsNullOrEmpty(cwd)) + _psi.GetProperty("WorkingDirectory").SetValue(psi, cwd); + if (admin) + _psi.GetProperty("Verb").SetValue(psi, "runas"); + + var s = _p.GetMethod("Start", new Type[] { _psi }); + s.Invoke(null, new object[] { psi }); + + return true; + } + catch + { + return false; + } + } + + public static void OpenLink(string url) + { + if (!string.IsNullOrEmpty(url) && url.StartsWith("https://")) + ShellExec(url); + } + + public static bool IsAdmin() + { + using (WindowsIdentity identity = WindowsIdentity.GetCurrent()) + { + WindowsPrincipal principal = new WindowsPrincipal(identity); + return principal.IsInRole(WindowsBuiltInRole.Administrator); + } + } + + public static bool RunAdminTask(string args) + { + var exe = Assembly.GetExecutingAssembly().Location; + var cwd = Path.GetDirectoryName(exe); + + return ShellExec(exe, args, cwd, true); + } + + public static void StayAwake(bool enable) + { + const uint ES_CONTINUOUS = 0x80000000; + const uint ES_DISPLAY_REQUIRED = 0x00000002; + + uint flags = ES_CONTINUOUS; + if (enable) flags |= ES_DISPLAY_REQUIRED; + + SetThreadExecutionState(flags); + } + + [DllImport("kernel32.dll")] + static extern int SetThreadExecutionState(uint esFlags); + } +} \ No newline at end of file diff --git a/app/MainWindow.xaml b/app/MainWindow.xaml new file mode 100644 index 0000000..f93d6ab --- /dev/null +++ b/app/MainWindow.xaml @@ -0,0 +1,105 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/MainWindow.xaml.cs b/app/MainWindow.xaml.cs new file mode 100644 index 0000000..046b8fd --- /dev/null +++ b/app/MainWindow.xaml.cs @@ -0,0 +1,173 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Windows; +using System.Windows.Controls; +using System.Windows.Input; +using System.Windows.Interop; +using System.Windows.Navigation; + +namespace ParsecVDisplay +{ + public partial class MainWindow : Window + { + public MainWindow() + { + InitializeComponent(); + xAppName.Content += $" v{App.VERSION}"; + + // prevent frame history + xFrame.Navigating += (_, e) => { e.Cancel = e.NavigationMode != NavigationMode.New; }; + xFrame.Navigated += (_, e) => { xFrame.NavigationService.RemoveBackEntry(); }; + + xDisplays.Children.Clear(); + xNoDisplay.Visibility = Visibility.Hidden; + } + + protected override void OnSourceInitialized(EventArgs e) + { + base.OnSourceInitialized(e); + + var hwnd = new WindowInteropHelper(this).EnsureHandle(); + Shadow.ApplyShadow(hwnd); + } + + protected override void OnClosing(CancelEventArgs e) + { + e.Cancel = true; + + if (xFrame.Content != null) + { + xFrame.Visibility = Visibility.Hidden; + xFrame.Content = null; + xDisplays.Visibility = Visibility.Visible; + xButtons.Visibility = Visibility.Visible; + } + else + { + this.Hide(); + } + } + + private void Grid_MouseDown(object sender, MouseButtonEventArgs e) + { + if (e.LeftButton == MouseButtonState.Pressed) + DragMove(); + } + + private void Window_Loaded(object sender, RoutedEventArgs e) + { + Loaded -= Window_Loaded; + + if (App.Silent) + Hide(); + + ContextMenu.DataContext = this; + Tray.Init(this, ContextMenu); + ContextMenu = null; + + ParsecVDD.DisplayChanged += DisplayChanged; + ParsecVDD.Invalidate(); + } + + private void Window_Unloaded(object sender, RoutedEventArgs e) + { + ParsecVDD.DisplayChanged -= DisplayChanged; + Tray.Uninit(); + } + + private void DisplayChanged(List displays, bool noMonitors) + { + xDisplays.Children.Clear(); + xNoDisplay.Visibility = displays.Count <= 0 ? Visibility.Visible : Visibility.Hidden; + + foreach (var display in displays) + { + var item = new Components.DisplayItem(display); + xDisplays.Children.Add(item); + } + + xAdd.IsEnabled = true; + + if (noMonitors && Config.FallbackDisplay) + { + AddDisplay(null, EventArgs.Empty); + } + } + + private void AddDisplay(object sender, EventArgs e) + { + if (ParsecVDD.DisplayCount >= ParsecVDD.MAX_DISPLAYS) + { + MessageBox.Show(this, + $"Could not add more virtual displays, you have exceeded the maximum number ({ParsecVDD.MAX_DISPLAYS}).", + Title, MessageBoxButton.OK, MessageBoxImage.Warning); + } + else + { + ParsecVDD.AddDisplay(); + xAdd.IsEnabled = false; + } + } + + private void RemoveLastDisplay(object sender, EventArgs e) + { + xAdd.IsEnabled = false; + ParsecVDD.RemoveLastDisplay(); + } + + private void OpenCustom(object sender, EventArgs e) + { + xDisplays.Visibility = Visibility.Hidden; + xButtons.Visibility = Visibility.Hidden; + xFrame.Content = new Components.CustomPage(); + xFrame.Visibility = Visibility.Visible; + } + + private void OpenSettings(object sender, EventArgs e) + { + Helper.ShellExec("ms-settings:display"); + } + + private void SyncSettings(object sender, EventArgs e) + { + xAdd.IsEnabled = false; + xDisplays.Children.Clear(); + + ParsecVDD.Invalidate(); + } + + private void QueryStatus(object sender, EventArgs e) + { + if (e is MouseEventArgs mbe) + mbe.Handled = true; + + Tray.ShowApp(); + + var status = ParsecVDD.QueryStatus(); + var version = ParsecVDD.QueryVersion(); + + MessageBox.Show(this, + $"Parsec Virtual Display v{version}\nDriver status: {status}", + App.NAME, MessageBoxButton.OK, MessageBoxImage.Information); + } + + private void ExitApp(object sender, EventArgs e) + { + if (ParsecVDD.DisplayCount > 0) + if (MessageBox.Show(this, + "All added virtual displays will be unplugged.\nDo you still want to exit?", + App.NAME, MessageBoxButton.YesNo, MessageBoxImage.Warning) != MessageBoxResult.Yes) + return; + + Tray.Uninit(); + Application.Current.Shutdown(); + } + + private void OpenRepoLink(object sender, MouseButtonEventArgs e) + { + e.Handled = true; + Helper.OpenLink("https://github.com/nomi-san/parsec-vdd"); + } + } +} \ No newline at end of file diff --git a/app/ParsecVDD.cs b/app/ParsecVDD.cs new file mode 100644 index 0000000..8197d4b --- /dev/null +++ b/app/ParsecVDD.cs @@ -0,0 +1,310 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Runtime.InteropServices; +using System.Threading; +using System.Threading.Tasks; +using Microsoft.Win32; + +namespace ParsecVDisplay +{ + internal static class ParsecVDD + { + public const string DISPLAY_ID = "PSCCDD0"; + public const string DISPLAY_NAME = "ParsecVDA"; + + public const string ADAPTER = "Parsec Virtual Display Adapter"; + public const string ADAPTER_GUID = "{00b41627-04c4-429e-a26e-0265cf50c8fa}"; + + public const string HARDWARE_ID = @"Root\Parsec\VDA"; + public const string CLASS_GUID = "{4d36e968-e325-11ce-bfc1-08002be10318}"; + + static IntPtr VddHandle; + static Task UpdateTask; + static CancellationTokenSource Cancellation; + + // actually 16 devices could be created per adapter + // so just use a half to avoid plugging lag + public static int MAX_DISPLAYS => 8; + + public static int DisplayCount { get; private set; } = 0; + + public delegate void DisplayChangedCallback(List displays, bool noMonitors); + public static event DisplayChangedCallback DisplayChanged; + + public static bool Init() + { + if (Device.OpenHandle(ADAPTER_GUID, out VddHandle)) + { + Cancellation = new CancellationTokenSource(); + UpdateTask = Task.Run(() => UpdateRoutine(Cancellation.Token), Cancellation.Token); + + SystemEvents.DisplaySettingsChanged += DisplaySettingsChanged; + SystemEvents.SessionEnding += SessionEnding; + + return true; + } + + return false; + } + + public static void Uninit() + { + //Config.DisplayCount = DisplayCount; + SystemEvents.DisplaySettingsChanged -= DisplaySettingsChanged; + + Cancellation?.Cancel(); + UpdateTask?.Wait(); + + Device.CloseHandle(VddHandle); + } + + static async void UpdateRoutine(CancellationToken token) + { + // TODO: restore added displays + + //int initialCount = Config.DisplayCount; + //if (initialCount > 0) + //{ + // for (int i = 0; i < initialCount; i++) + // AddDisplay(); + //} + + var sw = Stopwatch.StartNew(); + + while (!token.IsCancellationRequested) + { + long start = sw.ElapsedMilliseconds; + + Core.Update(VddHandle); + + if (token.IsCancellationRequested) + break; + + if ((sw.ElapsedMilliseconds - start) < 100) + { + await Task.Delay(80); + } + } + } + + public static void Invalidate() + { + DisplaySettingsChanged(null, EventArgs.Empty); + } + + static void DisplaySettingsChanged(object sender, EventArgs e) + { + var displays = Display.GetAllDisplays(); + bool noMonitors = displays.Count == 0; + + displays = displays.FindAll(d => d.DisplayName + .Equals(DISPLAY_ID, StringComparison.OrdinalIgnoreCase)); + + DisplayCount = displays.Count; + noMonitors = DisplayCount == 0 && noMonitors; + + DisplayChanged?.Invoke(displays, noMonitors); + } + + static void SessionEnding(object sender, SessionEndingEventArgs e) + { + Config.DisplayCount = DisplayCount; + } + + public static Device.Status QueryStatus() + { + return Device.QueryStatus(CLASS_GUID, HARDWARE_ID); + } + + public static string QueryVersion() + { + Core.Update(VddHandle); + Core.Version(VddHandle, out int minor); + + return $"0.{minor}"; + } + + public static int AddDisplay() + { + Core.Add(VddHandle, out int index); + Core.Update(VddHandle); + + return index; + } + + public static void RemoveDisplay(int index) + { + Core.Remove(VddHandle, index); + Core.Update(VddHandle); + } + + public static void RemoveLastDisplay() + { + if (DisplayCount > 0) + { + int index = DisplayCount - 1; + RemoveDisplay(index); + } + } + + static unsafe class Core + { + public const uint IOCTL_ADD = 0x0022e004; + public const uint IOCTL_REMOVE = 0x0022a008; + public const uint IOCTL_UPDATE = 0x0022a00c; + public const uint IOCTL_VERSION = 0x0022e010; + + static int IoControl(IntPtr handle, uint code, byte[] data) + { + var InBuffer = new byte[32]; + var Overlapped = new Native.OVERLAPPED(); + int OutBuffer = 0; + + if (data != null) + Array.Copy(data, InBuffer, Math.Min(data.Length, InBuffer.Length)); + + fixed (byte* input = InBuffer) + { + Overlapped.hEvent = Native.CreateEventA(IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero); + Native.DeviceIoControl(handle, code, input, InBuffer.Length, &OutBuffer, sizeof(int), IntPtr.Zero, ref Overlapped); + Native.GetOverlappedResult(handle, ref Overlapped, out var NumberOfBytesTransferred, true); + + if (Overlapped.hEvent != IntPtr.Zero) + Native.CloseHandle(Overlapped.hEvent); + } + + return OutBuffer; + } + + public static void Version(IntPtr handle, out int minor) + { + // Remove() takes only 2 bytes for index + // so this 4 bytes return could be a combination ((major << 16) | minor) + // it should be clear when Parsec VDD comes to v1.0 + minor = IoControl(handle, IOCTL_VERSION, null); + } + + public static void Update(IntPtr handle) + { + IoControl(handle, IOCTL_UPDATE, null); + } + + public static void Add(IntPtr handle, out int index) + { + index = IoControl(handle, IOCTL_ADD, null); + } + + public static void Remove(IntPtr handle, int index) + { + // 16-bit BE index + var indexData = BitConverter.GetBytes((ushort)unchecked(index & 0xFFFF)); + Array.Reverse(indexData); + + IoControl(handle, IOCTL_REMOVE, indexData); + } + } + + public static IList GetCustomDisplayModes() + { + var list = new List(); + + using (var vdd = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Parsec\\vdd", RegistryKeyPermissionCheck.ReadSubTree)) + { + if (vdd != null) + { + for (int i = 0; i < 5; i++) + { + using (var index = vdd.OpenSubKey($"{i}", RegistryKeyPermissionCheck.ReadSubTree)) + { + if (index != null) + { + var width = index.GetValue("width"); + var height = index.GetValue("height"); + var hz = index.GetValue("hz"); + + if (width != null && height != null && hz != null) + { + list.Add(new Display.Mode + { + Width = Convert.ToUInt16(width), + Height = Convert.ToUInt16(height), + Hz = Convert.ToUInt16(hz), + }); + } + } + } + } + } + } + + return list; + } + + // Requires admin perm + public static void SetCustomDisplayModes(List modes) + { + using (var vdd = Registry.LocalMachine.CreateSubKey("SOFTWARE\\Parsec\\vdd", RegistryKeyPermissionCheck.ReadWriteSubTree)) + { + if (vdd != null) + { + for (int i = 0; i < 5; i++) + { + using (var index = vdd.CreateSubKey($"{i}", RegistryKeyPermissionCheck.ReadWriteSubTree)) + { + if (i >= modes.Count && index != null) + { + index.Dispose(); + vdd.DeleteSubKey($"{i}"); + } + else if (index != null) + { + index.SetValue("width", modes[i].Width, RegistryValueKind.DWord); + index.SetValue("height", modes[i].Height, RegistryValueKind.DWord); + index.SetValue("hz", modes[i].Hz, RegistryValueKind.DWord); + } + } + } + } + } + } + + static unsafe class Native + { + [DllImport("kernel32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool DeviceIoControl( + IntPtr device, uint code, + void* lpInBuffer, int nInBufferSize, + void* lpOutBuffer, int nOutBufferSize, + IntPtr lpBytesReturned, + ref OVERLAPPED lpOverlapped + ); + + [DllImport("kernel32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool GetOverlappedResult( + IntPtr handle, + ref OVERLAPPED lpOverlapped, + out uint lpNumberOfBytesTransferred, + [MarshalAs(UnmanagedType.Bool)] bool bWait + ); + + [StructLayout(LayoutKind.Sequential)] + public struct OVERLAPPED + { + public IntPtr Internal; + public IntPtr InternalHigh; + public IntPtr Pointer; + public IntPtr hEvent; + } + + [DllImport("kernel32.dll")] + public static extern IntPtr CreateEventA(IntPtr a, IntPtr b, IntPtr c, IntPtr d); + + [DllImport("kernel32.dll")] + [return: MarshalAs(UnmanagedType.Bool)] + public static extern bool CloseHandle(IntPtr handle); + } + } +} \ No newline at end of file diff --git a/app/ParsecVDisplay.csproj b/app/ParsecVDisplay.csproj new file mode 100644 index 0000000..93ac694 --- /dev/null +++ b/app/ParsecVDisplay.csproj @@ -0,0 +1,162 @@ + + + + + Debug + AnyCPU + {2D44934F-B4CF-4F2C-BD03-AE60B71AD045} + WinExe + ParsecVDisplay + ParsecVDisplay + v4.5 + 512 + {60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + 4 + true + + + AnyCPU + true + full + false + bin\ + DEBUG;TRACE + prompt + 4 + false + true + + + AnyCPU + pdbonly + true + bin\ + TRACE + prompt + 4 + false + true + + + + + + + Properties\app.manifest + + + + + + + + + + + + + + + 4.0 + + + + + + + + MSBuild:Compile + Designer + + + Button.xaml + + + CloseButton.xaml + + + CustomPage.xaml + + + DisplayItem.xaml + + + + + + + + + + Designer + MSBuild:Compile + + + Designer + MSBuild:Compile + + + Designer + MSBuild:Compile + + + Designer + MSBuild:Compile + + + MSBuild:Compile + Designer + + + App.xaml + Code + + + MainWindow.xaml + Code + + + + + Code + + + True + True + Resources.resx + + + True + Settings.settings + True + + + ResXFileCodeGenerator + Resources.Designer.cs + + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/app/Properties/App.manifest b/app/Properties/App.manifest new file mode 100644 index 0000000..c522bb4 --- /dev/null +++ b/app/Properties/App.manifest @@ -0,0 +1,77 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/app/Properties/AssemblyInfo.cs b/app/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..153efa5 --- /dev/null +++ b/app/Properties/AssemblyInfo.cs @@ -0,0 +1,55 @@ +using System.Reflection; +using System.Resources; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Windows; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("ParsecVDisplay")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("ParsecVDisplay")] +[assembly: AssemblyCopyright("Copyright © 2024")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +//In order to begin building localizable applications, set +//CultureYouAreCodingWith in your .csproj file +//inside a . For example, if you are using US english +//in your source files, set the to en-US. Then uncomment +//the NeutralResourceLanguage attribute below. Update the "en-US" in +//the line below to match the UICulture setting in the project file. + +//[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)] + + +[assembly: ThemeInfo( + ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located + //(used if a resource is not found in the page, + // or application resource dictionaries) + ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located + //(used if a resource is not found in the page, + // app, or any theme specific resource dictionaries) +)] + + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion(ParsecVDisplay.App.VERSION)] +[assembly: AssemblyFileVersion(ParsecVDisplay.App.VERSION)] diff --git a/app/Properties/Resources.Designer.cs b/app/Properties/Resources.Designer.cs new file mode 100644 index 0000000..ab3fb7d --- /dev/null +++ b/app/Properties/Resources.Designer.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace ParsecVDisplay.Properties +{ + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources + { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() + { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager + { + get + { + if ((resourceMan == null)) + { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("ParsecVDisplay.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture + { + get + { + return resourceCulture; + } + set + { + resourceCulture = value; + } + } + } +} diff --git a/app/Properties/Resources.resx b/app/Properties/Resources.resx new file mode 100644 index 0000000..af7dbeb --- /dev/null +++ b/app/Properties/Resources.resx @@ -0,0 +1,117 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/app/Properties/Settings.Designer.cs b/app/Properties/Settings.Designer.cs new file mode 100644 index 0000000..ac50bc4 --- /dev/null +++ b/app/Properties/Settings.Designer.cs @@ -0,0 +1,30 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace ParsecVDisplay.Properties +{ + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase + { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default + { + get + { + return defaultInstance; + } + } + } +} diff --git a/app/Properties/Settings.settings b/app/Properties/Settings.settings new file mode 100644 index 0000000..033d7a5 --- /dev/null +++ b/app/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/app/Resources/admin.png b/app/Resources/admin.png new file mode 100644 index 0000000000000000000000000000000000000000..dcc99a081ed9a1feae988b9b61b42a1e33a892a9 GIT binary patch literal 548 zcmV+<0^9wGP)cVc^=x;D2P4E$I zD^#i|YFzpcOuB8lFdCmRRwcHIKv3zF0ty)GW2-xNbY)`Z9+MdzM{U(fk-!;%8LmD%KMoqvj=~M&so}ISmko2yC^eh)Z8a9H41Yk$srUu}$ zo=E5Qd7Re*r!|koWgK9~51}mb>;8!m7(AgoGq7oTG6YVYUldsVq&OK4?aSR5ydf9{ zen9Bom@ZfnX`2-p$JO)3^{#04 zFBT$N-b!)H^+R#S{&l6$uElHOo@@OtRzt$(YAHgtX_$a?FN3(}qr^2+_adx@tT5co mmf3H9H|t}jrgSCYQqCRgKUTE*ffVZi0000(_`g8%^e{{R4h=>PzAFaQARU;qF*m;eA5Z<1fd zMgRlISV=@dRCwC#{aKppy3Pa&BIvxMsKv(2~<>;RBdXUS>jlJ>WDX1bLq zHb5{Cf&btC_y0pt2V{N#>G`GC+{fQMknjHkK^_6}0OS!MKM3-G$WI9JQyT9m{6; ztc{zK#!{VbkjA#2lgdIadCUU>1ob@BXP`d^=yeqH$rYHKKV3hh{XDGAYit2To00OI z6x;li?^AlL#2Ttkm)Bi&5B9B2Z;Igl@-^^F=5GA*J)k=aepmC|$Cq?(^gjU=3q!@o zaC1NGdNqxiC*kVkb-&UaE9drehs^i!>R8*_cgBDLHq8DuLDb)i3B1sPu98aNSNb^D zuFWUDt~odlW2bG(QzwrEz90k%2h{(u*z_7We)PM zZ{foHz?JXW2EMd@GV0!+bO-L^j+pP`KJMd{jB$HB{>!6%!}<8so-u&;SYqg3v&iM<^gn24V~_lYT<8UCKYR3>^%SSX&#f-<2+oNwsi$o zxPLH-tbu|2jQjE-9R@pJT$1|&z5oh@K>=Kl%ex?WAcHRraLJ6r#x6uFV}oD=JWLTL zrpNfD+|cY;58Q!1IdPo~qJWu|#AXJ(OaUCI9sfKiP!gdP5T<}+BM=7NDBxt|x;DZ} zV#65_;Gg#^E`NXQ9UeHp0VEx}RP(z7H`uXLda%rc8XD|~`8D$rBn8Y+m*dc2Egp=a z0e9HWy90aLHH^R)>hphrImeef&6h<59qA>{z3`<93nfRo;Q=>4OaK*q69HLd)^N6% zeq&Vj?mqG_fEPCyaUb__9}7#I)W?lL{Z;m=8F-Gh0afG8q2>rCt`p><%=fH2BU1ih8M>uzF~YD!9&rhez#``7ylY?#^VVK z8}?ui!X)AaEZ_hbMoR@_BxGhwX1vtb1PORZc!cgfwFF5t5VP$jYVe_SI&7Hvs9KYt zWoC3B%S7k}9*Nng>7oTJv9tRZ5XLiMq|Z%sqF7pnYW6CB8Max62Qj}-26Y@ z{YI5gQPXor0Wkk&Q`F7$m3YVON@6sW_GY8KatRKNYWzz7S^RdD{1;$Cm+O#a9BTT5 z0$4CB@ZySQDwqVal|~sML#s#aNaZw9Bjc2z1s<^ z_IaRERzHs^&Prn~`^8EYY%gyAuL9qMyn{&$f`SS?4U(%n%Y|lLnnqD!N~yqKpAKEl*V}+%Ps`5I9_|>c-1KF@yJe$$dsu&} z9>g^ID0zHQyj`2YUvhg-u8UUv!}DpZ>8IXFR2IzD<)|=Q3e%+kF&Su444A}>$)!l4 zl^%tn9iu=deQg-rH`Y|Db*`obGur)}068joUW1Fh@U8`2Hh?b!*2^}4Ix|%UqDZiq zl3}2|+&vcxxyV^^GkS;%Mm4sq;QZ8-Zpe+(uI&pkTR$Vk6iK=pu*F*Z`W&d|VA^(2 zdMaYsB@Rt9ZKdRUJLZbjbMY3@x$H>4kM>^C)evdnUU5tqsuR$C%=FLtQRr7I?sDFq z!z{lpFR>D!ZalxC7vRbk9mVTK?F^R5Md_F`B4=&^B(F|iH(ldzM~NHy(Z>g~{{RSs zPwz+faUc7;Jf|TOR+oakRX5*4hWK#|>-xj&{#Hf|oS5cR5#bBqgtb>#SRj<0M5t_# z{8;~lcefyIX1`71gUbs}k2Ca%0zS1xxD*7!jwP|BIspj;(OL$8P1yBUn79dCNc~~P zI_X(6sO3e?db%-SED)2D(geIDhD!ouLM=}!KulrLXaQcV#(`e`k%qNn`v&`F#|VU( zd|yvl*|a$58w2ruf4@3UHw=u9%gQ{%F*stf)WQ2XqO|R?EH+=kVKi?NxD$f>G2_Jo z5TlYRZnz8S?WK>>=8w5AC3XxI6Xwk`5oD}q%B6eGzFkH@n%K8DJs6I`m=VLJ+ye!U z^-f9so#B9qRlnbr9+4hGbRZvXaUORy>Un9-Hr1UI5`SO0BfXjQ2Zvk-JO9xydIiD8 z!PEPc7;$n9c>9gKj~(OrKJMdhXOw@NT{zq4_!*}@XdsIMUvwE#(B%qWIm696gV_Z% zte3otRJAF#@c#c!2lAi^yP#K$1Laz?Zwe3{NW+>ZmxO{VXeTf3pMwlgJCEdF!QN(7 z1DT-|0R;$R0yd&VB@<%>O`AR_d*EW#YF49HdRJ6wy=3qtWWdFMFiM;^;VT(*5$%{1 z6riKnHNZYJdkAQ7gjAR|@uJNm5N2dItpOQy;Fq)#qe*9;mR7BFAxJ7gN~Mn6oN~-l zX!eYOp?&lg&6hzfqR_G%y0x@T1V(d+XN@{vZo|PPvMd~Ue~}&Wz4Ye z2dr}=}NhX9*5g_Pe20(>P4 z=9}X1Bjfo7!S3Te{?hTIQWOKeNCjU~Swtvh2L_CRDW&)eKpb;mor1}f3=yRa2@>*7 zUqA^qwYnw$o({}nz%g)+@%>@}bg9`bn*$6+W(bQQ4wR`5YT1$2a(El?;!=XvBq=2b z8F3-nqoE4ZCKyJd2!aSBYnk8Z(z%M3&7WgV_A5M9X@1&z+PWSgWOt+RkVpMJ|9jZK zAFc#RfC}7LUD0J8d6q&|{}v)2+z94|2giUFHm!!yS22X87tdv`F^B$!i`4u*ne+Wjq?OWnvw@ zpU3WnTyY=1H3<9**YH&*jsxTQKJMc_{vZGYhee@Mv1`de4lW-fCd{|tFH-^2qVbAa zepKefXqYc$N4jau@rs50%a=Xwz9(!#$Hq=~0%PD)E`GADON#d8(C%TO4z|XCVGJS? z1tAC-t2K1HT)3|tFceTz)A>!HE+4ag)|&m&%8&{hrZ8L_5Tk*b3ce(-=^6O4U7%JE z*>Mu!lOqj&r19xkBa`U>BS;8?$2ZBsK(;zjQ(Lc^Qon|(6edQw76bWGrFURg6*(+i zp-$8}pA4PY=@cL^z?i21oty0V5*cGnT)=?t8V8!qx!suoP_2cuylRX)5>8~>SwUyb zFw*BKQxJ?IwiHq($jFpE#I9t>3-F2qW5khGggr>-E1^8-LC>+G0|h%Ew)JkBxxpc= z`aEroR@XV!w^Dv%jmNQ5!Rd=#HxkAm3O0Z)TQ8+o`+4=woF1w1?caEAKl-YK{}1n$ ze@#ESkNa5b$hT|UMgT^Id>U|(;&76HmR5#T{)VxX{d#Tk9PCEq`v08JMq$$Es0mH_ z`zeiDf3sj@qZ7l%Qdh^~z{f1Z9Dpx$z=mTd)C5_9Fs0n8i0%r6K}2E@mj1VN!J~$x zQ%;!ds8o=qh)64XeK5Au7GTjVmT(yutdm7C*66l#N z+vD*K*1x(fMLJdrN0bm-6Ex7}8GeoZ&ZRRPoDVz9gbLoKn+F`AGsC3yyvgZ6IU(=) zo#e@Hue}~Ra}k={)>zzi<|D9Y`BTck}e=PC;;Qo7B@OcAB(jw8jH{ZvXj28Ue zYxtQx>79-+0AGS}Mf$#0>PtFGLRz#KC{L#AEg(#+)k)a}!w0ATGC+-2-pE}a_v^jQ z@1!d5#Ry)~hQ7MoDipmTNus-yC(Dv%A##hG7Sm*4@&0?t}X?B$-YUBzYy79jR(tedxOX!BL&^7V2Zw(l<-TEqOZw4GthtXr2HJdsRNK!W zu55{m+U*O1ssR&Fgn3H|68?q;Z{1N&L2iV|BZDwNkxflIyg;(1e!6AhU!2Eq!fW9g z4j;MjjuKTm=8I;(u=AHN)hR%NU2^}5*$asX$FG(yX@*LQYx0Vk-1Q>2%Har)#BRxD zN6CIV>%OS6qX(c$ma_JXIPgVmanCvnCc`Wl(CF-?C%uD`?Soa)PX$-J#8SidUIOVs znEqTlY-BkyDvTDb_u|J5d>*N3FxH7kmx&AujM%&8$jEh!8UWKs*~B9Fg|SCnDkCnD z_F6E;(Z>xw!-_&?GQx}lQLcZU{Q^ySF=e=CFnt{J&)ierANn3$IZ~xFK(Ua>U5gYp zbj$Up(LY!FFn9O}_RI?->??kfzzkQCT`owwUi3W?z^eNoj*ZdxF2{VO7vG8hovGi) zecZmAfS77U{mqRD&FYZ*Xx#`rVF z2q(uMIN_@n6M$dGVP@b9WmK!70nQ+h2udK5>yau0;^I!WKMC7HEL;DY9io<4@OI z%Z&+BM0iUH5;DM|g?N?gQ5Nbgx-aGRJ{2^xkSg84G9;n$%{JcF5`(IhqCguDN?aa7 z*6G5bFPH!?d(H-mV8b#$yHc{khnUqOL5xKW7l1`kV$$?_95Ml7-2KE!$(d;?)2FR{ zF%82(e*h|&SGA_RYq)2&IFKdTuD1uux+ofydEpAF%e5R3Q$Y)$X_-{4p@1u6kfk&A z84Lm_C%=IV(OBbE&0E##9ctWhEsYx$-_6G3} z#~DH0jv=v@XTup`d}3a%&*`V}I&^;2Xx9PG4N01?X48Se_ajv$p+QPuBVjhuQpu5W ze|HT{KuYyFswp0!c+?Yk%(X9gOKDT%PsqR8-we3v2QGkV!x^HRn~=?U3qL#nPt<3 zHKwPk1~^&vLvd1a9@ax~UJt%d{XG?T#^7A3;h@t{&+5F>0LKPi6aX^1aax3qQ`sn# zERAKpG?Ys%=-RDJEtDhh1qXX-)z5(gV#xKLyW)TaEw(*kj}^zQ5u0kDZ3d?!z_Ir8 zI5^^fwRM1(W;JS>;5L_lnJx492#`_0=8B2?FGR095T_F)lFrv9sgAjZBFR4lvXfh+C zm!T}wO}>#`kdi8mWw&S$rV8vXs?%n+m;#whUW0jI3P-=Z#5VsW(64}EGS<9VOFUZ+ zKBF`!c8~#ja={f`nxD&UILbw~fG?|>ARKfBp4OK7JV{q>RBe`}(@)hpNYG3e&4O|D zf-q%AQ0`W6>!T{d-M#XcQak6}v$%W1jm_(k8C%0P6n<7Lm1F#}w<6a3?crg?k(Y1x4isuJ}V7jhmN7mLroHU8S`5j@hx`R!owU%ZBI z$Taz7_uxM6<2ab|Drj-#``!h-bO21ZS)j~UHT$Jl=+<3uk*Wjp7kW-)DWiyOS5Tx6 zV%UPx4@mPq2BE<_2l=POk#$F&EfMr0yo2hQD#8n@L~yVhzjNlR;F#^+Ijg zYm!UkQVXU1Bq|XV>Hb|2dib5^uU?R(F=Eylz?X z!GMPjkLf&yCp&exer#&MMW0UvU%WVPoxru5)pAdSINc^A7>(}#a%8Bkb%H@z3`bT# z3!mWumJ!dyRxtGdP5B?Q?inhM*VaCxIi33{Wz2Z-6;nEi?qH!wj@>yS@j!cX-|M!! z`+UNJ=fGHe!h-z@@PdPF@h-N@Ck86_HGF(P@K0Uyef;YOZttx*05fhem<6zv8nr|$ zD1hb<;4czDc`EBq7#Eu?!mIbyhPCv6d%DCREW*|o{)IzZ+=^woPzUa`cCCg5qtrEf z{iGQfvkk1M0-U1ktXXzLn>Z(x2&rM+AdT#z10$WQk;op%RTT-S-)Pwf(>Q|%ldNx# zy=?YrK^XO68T>BEtQP6@&zYK$POQ|6@KOPbvI4&BNovn+#0I=H8)^|(hUaUw^t6Pr zt5&xTDuN4~sy1E?lm|Y^9oxuh-qgpM;LX_4O2!}_)cgR|msmFyGU!sVD`XNId!R*{ zu1@VuwB?qH;Ns+JEHLCtnnqNhJ?m@tTE25GSu26Wb&1xivF=;f?7e=6Zr*w+;JWZ0 z$h*$z8?J$W;6Cu=*MGv5-J;6(@vfNd24D68FfLHFxC|Tx`ww)HvU{8<)K&Av#@pSz z<#7h0-{}5Yl*RnXVcLzAQ0dRkCnCMxF8vcN;@4#cwatLuEo9ZAdAXqp%?1cliUca94sV|% z_Mtf*;3+X5Fz`4yH<|t_;sKVrURe#7x{=`Aj?AWmW{RCUztOTRMnd1_;RZahbF$)s z9*i@{618X*Fa@anEi#qdMhzG%XEo$b8JJ!RRazNyS4-uVib1N@$f8$-jL3M_R$=E= zac$wcIPmMZo&~~Q$fq#ti}!INxOF!5?l+TCtUS&y=ttOi{@*qh_FlscZrsOxe8tE% zrX|NVlhqcF@S3_-1p8F8Y)Dpue0u56?iOtJPS-K-4_GC>}9EKoKJcn z#tUnUEqh#$h3(Q*Sipr~2l{Evs2~YE2^5KWtft?yE?O>ijM8+{LIwf@8U`ICy{E|c z7VxiOuu3#W#Ia&v%OvTZ&!DnTkG7{joL7OpWsHC2#Po|`#QK!^Hh1a|Y?J%^?`v2- z`h=1^_J4WY?+6SuDD zSq}AaQ*L%-mg3>j!qLYlN(8Q&F`S!`22v`p5|ZFi2$CJWf@OUL1w#ToL+#S?TP=vo zj%8QaFLaty#-ZA;YX+&X{l{pX<$h;DnDk@UBbT?)|B`ScY;W-*~fhtYXPI2hU z=!!-WWMFP?N|i>P9*27|H$@5mO2)!B&2xk4VeM=#xdr^?w!Rrs_i-Qh@mJT9&zs-K zK8)KM*1aP5djl}j5DTke7>2GSe;<4>Z2o@)aM=^GQL|sfS>;Z4Td|skqD!d9AuAP- z<8t$&-(VCooAotXrmBRu;iaHnyw_T>^PRZ@ziIMW0b+8x+LaLXj!3N(ZKQ-MMv!;W zs+C6;Q7*G+oFi53qQDo5)@tZK#FPm+yIqr5nfz*$q|MiVn2`&al}}(90y@@8Z_I8! z)l7ERyo2SZOj(Qu2MT}&_3BzX=oPK@-(6~<=><<}Y7HNc4UFDuWM;0rM_SLNIesPJ zC1k**KBvGJBfe`t%w5EiPxo4zNk9In<`we-B|JRr+8n?PTUYnS@~J%rN)tzeSh*R3 z2X0|M!wMGfgY6f4>e7?gv9KSE2NpWn2So%t|1E{x`J&$^Hd*k#Gw~}Z*Wy6Reo8n4H zP)wEOY9tQ6kSC0T`JK0#3*0ahWXBcwGKXvK3stEG=UT1b5f?4)G2HDX3<)yksPsrI(c)SQ$QxRQl){l~wLtAITe z3X7RsW#pBaMpWO$)kWd#b^5|cb;RHPhU@qXA?nw}iQCt;&$+n2a1FDox&>eE<3q>R zKXmLaL4vnK!ryAf;>ys13^&tuwdVIE)-6i^(ztRP)4iiCr&tLlYc+MoqO;wSm@c^; zlGjabrb$0#SnyfN5eM8N6W<3vrFJht^Zn6aOLWA)WY56<8_%4duwn?wjR># zI1y_fzJ3eFR#<~VTx%Px$1$~juCf8Nz{8b^%BZYJ8~|kSrY$8(UEA0rNlu$MB^?;;&u9ecZ==d;tJ6+Iq*JQXk*%f>U-3 z0Uc1#B*2abaQC1ETk3!7(4|K>!(f-x zDJJ>b2{)<|HrTOXy5_{fFc@_naB$taOS1!{M$d5ow$xUPBEr~gsJoIRntRmWM0-OU ztfJ0gmXHpto~>+9>r2keekC{Iwr;^e&OZf8?A*96)H+zh6*Z-P5;(^M{^=}?`+%FH zfX|t8!Cwot?&SYI?&Ci0<8J~m@F0wlj8H}KfMdpdVeBB8o?j@`fEA`3StJ$eHUFiR zaNEtrzr==F)M8M;!$N8b1I%EM3sI97j9e*C4TgQnt_Z8Tghl6fng~!Vt^IW1oNr1w z(pjFC~DN=8JK7K_ltE=B% z`V1D@qOV=?#?InPw{=Z# zm!PZY129`@!ft$Cv0mbZ&wIyv`_I9KtNDAGF1cTJg~Jy^ySB>6483Wt(7cu_85a*p zX1j#6x+g7v9yM4*#p4-j{q{i3X*XqXQq%kM){>V`0b6{Nao+?r09A$wDY+w2JK9%| z&c)0Lw(kI?@3YSP1@WL?DHQPDml|4DNSEA?K-&QrQ@|Y>f$#i3S}b$tzS@>!pC)!%;XDA{`HYbM$cGd2cR&Y3t{_F?@#Yb{-+Gh52-Ove|UyF2wA zC$!525#H{(k^YMl-?bT}b)(wcT&8-;%{fr(U{zUmUguZmcRc&0cri&`d#!tZ_;PLp zkj`vayy3k#^z6A;`j2J6U#B2{ktc!Z!d$zkg*eCqWJ7Yx^~<>Ay=#MLlkOuX7y5_RgU(LYxx);3 z0ZY1v3W%X{wbA+Nc_-g2O;{LUWmFJ@vnn~7(}gh${Sw85*WQCIU(=l%hkYAgkI#&R ziI?w$CR1PgjwXD^Wclv^YCRy z`hBu0aywZ~6bRZbQB&2p%_ZsNOp;oZSY#W!hx=EqcW1o()g&6{zGdUa(>Z6v7Zc$l zXZG8{2>!q|+{bsu1^00u*Y&bb4xf)`$iKQ2{;bX88dHJ$VpK8SV&N%Y4Z`R^9L{R9 z?Hq2WWDfxePJ%Ivsk(dEENkY_eBr&@u64z-4~^RXH$w#aG{PijM#I6~e1bW_UrSEe zgD?wm8;nWxK&E#jQk#*Tku!~ui5*H4Oj&1`Y&aRmv94h zIPAj(Y$Pa%RdIGcu?@tDdt}|SRGbD3bt#w=z>_{Tf`- zm;apu|JGQzfw23ykNY?sfKk&36iNWcf=OjacnL}Rq=loEIJ0Ykl1w();c+qO2z=qD z#K4z-Z0EB00DoONa~>@9Qj_kUPjZdfB7C}Y-v_O0R0)zZF{!OhpBPiyySAi%wUa=# z9%19&nFc3xS%I!>pxSY!66O>etyTqIRxTLT1r^)&YD;SpKQTcwE(T%f-FrNHVCrbn zQ0A16v$jP6W-9RYaTpA{*~j!ZeeIpwP6Hy?GJEB=BSz$vp4?Y!d1u9ucD{AOI~&}H`P#zsO*t6$ypU7yWd^kDjXV1H za_`vqp~wh8``*P z{Tb&dxASc_s#)!OOM*pmoHrO>qj?BRv!hK@%`gPL97~2;&{Lfobt!|fnQddi)zxSr& zn#Wa(kw%K-ia@f$dw>;kcHj$@4KuY(_H;HIh`i(uT=&%3icb?L5d{pEtH&XoXCUl3 zNWj>uyfzcC9{6h4=|CC}E*c7uM>b2pRp84Y+tsCmX`JipRlYwNT%`x4exdXGYAhN3 zeby-|441nBna^M2F#UUlLyPTVO|P`lT;Yh5Xm|#hv~`w7O!!#5I4Z!lnCp=axVO~u zJxV**fe84LQSk|5`J8*oS@d<|JNI!P(|mmk7;`EB(=W{VKS$0d@T+`;jk>CBvR~1 z7Y5|e*0h+EGK@fsK|eD{%kXVBSu6>7RLLxLGN@fcq_G2vMJ@C-vI$iud=k@MRFfAp zROl+Qw{eUy8XFuo4@?4w%u14$z*1>LeNfz@ONKN;MuV2oB>7Eegz9My7#FPI+>rfp z@{I#%u>|#6%`_qDEXKu_;w&Q56O|cbv0n6!)}5WWxN3V5UiaRT1Wv#g{h8)|Il#Ab zA5(KPx*Fp7+FV$25Y19+47ZVf*Y8c=v}+D!47SM_q?w{OeUF-qxsxZXk4ZY$91YJ; zpx3y(^T(F%QeP_WUDt^X?Bb<>hdSPQVvVVVhB4fnO%F zI(VVzw_trG;ShM~`_Bdqhf~}!)~Y^)P$f%x z2R)WwBem2-j$2vFp#YIcNT^?qnv}PMxiLn{xX~IHe$Y`GyNp-#S|fczRa(;zUBeYn z5jt}K4+p}CT+7}$+7oTbinKBnj@d7!K8ZcB(OxTk8B(`2EI`DQs;{ADgc%PRaB()* zBvlELDy8Gd^4T(7L|aR1FvjZ`fsKvBi3W_(M)B887r#&5y8^zD{i4D>3D%6A2u#is z`Lv8Ej9R5erAWUqd($RKJHKA{p>=TcwZ&oGM0@Y{%7uyE$_K2)BS*HZh7CAXJl~NN z!!a$$t$#; z3df76FG8X_K`JenNU8+3acrpiKQs7}bRw((Z($9Tab?z@TLve2F44|0G2uwtKD_F5=75q|+PG_m{rk&RS>qykirUGMSQ7 zb5P^yfS3B&THDB-9~x>Yz3rOQcF}HLS@#5E@sPovgT$KLkeNGiUFlI5(ud>&>*`hT zWdxRCAkM{cChM-pmT~+-Qbdp1?R!5@dDZOR9}-5|xE}A(pEzUb_c|#sGPu}z7FYtN zxSYRky?#5h&~;_4EyYvfE1I#?fS3v$9|mEr01WU#-;)nG|4#y%)>>=k;fD>MfiWC2 z5}3Y^`?x`vuRMNsr{5UGcu?^izO>QVg3ao}Q2-{I1$?}4uTO^aofhn}j$SpIS}}Q8 z!$!!ppe6_38f=07V01t9zqZk=0RnspBF_QnVv{3slpM=q8AoBr6t^I+-J*CbX51~? zEOVG=iev_iDlv&RtFEO-AyW9rp1kOrilE;UGC!_!C8*( z@w~;j@q}ym+0=4Sfmxjp&~#v+!54g~6E*t4Tg~s-x%iOtz>&k?W;^4BnE6>~h9Vc( z&MV(Au-T?o``J@!25k5~9q-^XM$IJivsSTU^)=|UD8%V*kQ=|1;|+7J%y*dV>Cu8i zo;gg%SdVj3N@Uh^o#NEt1rPY$0b)6Z8pc=l-(* zY36{P+Nnt>!jOVz$U3g6w zMu>$Zffle7bx!OUGKG~Ts(glx)l$mo5JmWC&PVloqoI5+5nj5@`=N|P0lO^NY|B+? z%NZHF#|_J8z&JDC4HdlSlEUTkQO*_Pt@N+?-9A>8u&nquwFZ@TKc|ce$c7p}!{m6Z z>(jB_*iWRkT5-*0Y2-EbThZ(+7Fl69?Mlo);W(xd(ip|8w$q}4QDPFta3$FO*|lK9elWD6MRUlaP^9P|)bmIA%^YScj+0Fpr5Sj3FgfA=Zae zo*D!pW~*kG48a0S!#AsPCy3bg!YwtWW0*0NIipjY+#FGsJ$m^!CC2mREN6qC#6^xd` z*rEs|N(3ZC2m>mb$%VIgQg>gXMRrW3uJmibNb<~d)HY~3ZO!#+EZk{q+;txk z=bGh3p3MY9Hw|*3Rdfj!4Zx=FuLq`VyFs)(xNc*L?OW_om;N5im~xv$VYq=pa~1%B z*WSKqZGUYg-Nfqkw(RFW#9;xg6O-Ty$&FNKALFof?zZ+Ra-Nq)*vQdKp5v zk3%ijk0(rG>mJ-+Rw&|20Mre-+{gD#J390}+l}bmKuo!YpWUqmyLSy`MQkfjzHdSY zmH47St<{4?d*ejL!DMOuY;=r~(`T$(P;ZNFxcj}FzE@eo8XcI?PuSlkns$SIqhDGp z7U(7_aZgD|tjSwr8T8s3THut#cJtUmrRx2^r&~Bg9%d8ZhaQr z6%j$qmmCuRMQL&}LIh#t?QDfURS-g6b1SIv_!6X9`O#9x-4zQ`S=tZq$|)e~=2trV=Bj0+I1vh8M+K~cM2Qk2 zG6)kA^Q-9F3}n9GV&tVV(V?tL2e?RYXKloVEkMyg3i`A#J&vX+R&BN+y$fA8#X8Y& z|GNTWVl8hIQ_4s>Jsx*`^x9Z-1yx3vSOY`suorqbt1z1!=;AfI?E5C*I61d697Aaz zb~yBcvdf?nyArtZLe1@y!2JBzN|6?V-NIBsEjb#nrEt7?%Uafe7#GzTyX!mY{pa#W zICogAf6lUT78gL6^$|B_zTAEDK0b5>n@s&%mV-~hzL&0HI{<@0x{Vpw^5tl{H5Y3i0ll`Kc#xF5HJrPLneR%lOUg@fT%PK4?f+-o;;86DGimVN0|G$XoI< zQUNhhCA^tMz}OP0K?1cUP;Eq!wbB=EzGPa}Qn&jO6NpkjGXEW;FogVP%t==e#we_q zOAwLga&0}di1(Jx$^ExLd!4~1g=HmyZB*T06+nH6TZ8VO6VOFO`hJ^1m*^gA z{W$jnr75EUyj}Cj;to7i{<9Crp#v2=O&Ir)&BZEIT^L4)gdoU$JCYItBo?fdn z-^{Y|eD5%2S#>Ja@7%nc=x_#K%4)(=PKSgfYFEDzFU7N+C!OXntGY zgtFw74n4=OPfi=Y((0Pgvv6c^8o!$Bo?-dSyYFoUFyS&LcmQP7s*$P5 zv3{i5rB!646Bo&WHEfrx59sz${j7;=RGCK1iBCyjql`@~=j&mkyjSdgA7~x#j@(s@- z5RnSHG;k(5ao!CjNHerylkULI^xuI@FbQ5MLyGlhO6sDz_Zf^SFCkL$9#lR2P+|h= zKDUH%4?Hp2V;%|@JN=3-VV(9TSdnYRD4+u#_(8M$2ykiVIAFjiK!&k_Ec8OY!mfnm zEI{cLsf@17qz5vX^>h)Q8DLDhD2PaXJ3?Y8_S0ytZkGNuvO$`cr~uxVex7U&Y}u_d z5?yC^g5RP6%?7eG-O-}$1n1<1F+kwNm<#9<>)%qrn1V4!56DQxs9RZ*us-GimjvE4 z#!bPmwFZpEL#!w?*-{uPkW{lyZABEVUXWwNXklP(0#XLF8{f(K>S)38I{4P<=#?Fw zrO!LaH#cZZhp3O6sRLy8%(p&X<2n=O9YEF@{b<^kK4ra|fiUlE*RfbL%<_Q#LEqTU zRvJpXYXcUlv1M167WEb#GEk1T$VHgU$}@Tb)`g(C34DjtAwCd zWl$N6mu$7TzyOKm67;#o2DHQmq=CTzD$AaXSMFlb*b`f=j5QF(31kpQW-7pqLdKsS+j&}e>m)B7wmU5hGvR(m4#G*r!H68MON5}FR zuvlgSqL`eMNh)dBE!{=AvMP?i9@5&3PaJ_ZShDmZqy*mc)V8KbsVGKQ51Vm>&j>l=3BTgn@zU9BP+)^ zk~$rD!2l2%a=;zfJrd!yUDdItOyB15`^m59jrZ|~a^Cy60ho{Mls#avtfBKt)$-bu zJ1PNUzl`iK4Ti>Fx_4{9rHi)|l^3HOhCO-vUdO*7_@aKVB}Wr>i!M3xppErh-8p4l zxL}f5c-otx!z3R-5-M%a6;P%yfFKf(ZEmq*DuJf2a_U5F#ga#*NTb|!7|iRj3a|Tu zNl5;?APjwGYLaPbKp}fg7!fhzyHxGQP9x~Ef^kc18ZZ+`G2-S`XkCQzOb>>{peQx_ zWp~?KHgh0&>tMgh^BhQ)qLxJrap8doc=t(GVr+$t^NcH3GRz_A%eOv1F5}SIimb42cJ)H8MnVD*%e}AE zacF(lE-PJR=;MGa4#y&{B=>bXY8gkRr{$Pugii=8sACx+9DpRWZb!PrNJNzyHPEC1 zGwE{;1IEd3bt1i;we9HL&2TA&gn;YkIjZZ@b>L`bdN5>@;v65MkHWJsDM2~1tu!hlCUziA3fyBp|5!h-0yR~M zKt4hlssxPM9TQ~7$^z^o{$E+k(-9S=8{<6K-ymZ3UTdm%7Y}nSW*%&xn>57^Z}FT$a_|RWa^&x`OA{1L-K!^7h-&N0r4p4E77PfPZN=qebJ(vQ% zbO23rN%G>nB4R)h4jiLBAj8hCI+rAQkjGr7jOa9WF6m03IGS}9lAl>Q!A^i>!)q{} z(hkoqFM89xHG;u3BR&uXjWS=ha>Z&>uXKn~IWC4XrdPS!4`c0_bhhF!BgH;0;4awM zYqs3OVuwAZ?QsE&yKnPQWUyg^A-m(+m1qAzp=8q%eBBM|1+g1L|LGmZPW z0ho^jVU96Re)G(?12R+H5{x&gw16b$E{6@fnuz6iz%{z?;Z z3msR13;hoHjtmC9h5%8)Rfb;o zhgPZpWmjCCf`${%LPWo6D4}WK9z)`!|1Nd!0oS4ep&XEb&`-kXu`Fw><@H!JqlHa8 zcT!p;gR-OO7%v8laql-|LQy3|(hH%o17k28_oS=rqOx%x+!HU|#o1urIJNZ1-tmlY zWWH?Qh>gI+GVJnsBY$?qdl632p;_zT+-;VVTO3#i_PumlIXQZd zw9SIg@3;nx`|XNv!|SW=e55VDcXeMCb<>NKh4TEZR^|f%V8swz24QaWuQr- zuov_Js9I}!z(k~w=26M>%%wyQcyZE?X_0K8OfgpJ0`E<+$N3AP!Ju-&<~1}*KnazM zCZYfp6Q*hPfW`85sXPcx5Y;d83*bn{fmx7R;4p!8fW)c@uRgD(vDlBnQ8In?&RY)% zja;7;vxV#ve3g+x0f^*l3Cugdmwrm{6gN0Fj7lm9C3`4}9l|;O!B>au`UeaF!;wbJ z;>TOsJ5~MEmP;^hMdEZ|q%RYSUR+lk^TjwKwbvSnEV1B=2TSN`k2t|Xb#kHIkmz(< z=;fjm;=<9i0{7 zuwYasy$$<1@vh*McXP}6UvLfUz>!BO`jc8`!}RaNi@kndDSctXSP-TYcJ6j_J)>qJ zzNzmUl+K-rSl!2cTnJvQuCZUxcW(gZx4;;zKQ*n(HOtYF6|W>6y=dg@(}3-Z%%*^F zP>SRiQTW}YNdRTaU;QqL-t;x4FQy)$|5OLg)Q``LW1)f?vypsViCutJky9zl`{Pkw zQHqA1@k7^}Dyv1cVUSj3WX;IAA-MHIa@@Aw&uo4N=mVD!r_!2JHir{`isLjW^u~_xKhO;BZucHih0I5_NdW_HXLSd%iK53jmRQcdVY54VL^OR2b$9p zYQb)9q*Z+)Y)Uq$^?#4$qg<1C9szx}6-~(tWrMzk*Zrl@52p+qgG4&*6w6fcm>_$M zkRzaDJOz+*gBCh)#*8^%s$@#^UWEiOp1?N9mAof%#lAkcu-~h@prr*5=4|UAIY@#3+vOpIcv+4SjO`^hYra$Yw8^RYM$uK%t9SiU~rVoZ(Mc>*2gJ^|h#8?kuD z*3jZF5H#SRTx1c@(*agM0#ric$}>PD(vWXkxfCi;Q+IOfdWBs9K56Y!dhuCYvItVU zbq<3S4|rwaK^O3DbJwuI8b?5e4;4D_Wosj-gi!a-Fj5@F0Q>BtJB7oT-74cOdu|V|eRrSOa}8YE>>16S3tIrIu0i`C$8k>{ z&G8&W%6o1Q){!*r#2~Wko9^R2-U-BPNu~7u>&ITEyM`Np`5eUMYS`t}FL*^ncxhj4 z%xYOvB7_Nu3)oW0FPaJCV?#({Mj!}d6okCshLD7J1Db9|wps>43(RWmMh?Xd+lBL; zSoIo+cWCLeNp6z#;qH4#4PGr}ojG9#u;1PE086XOk+|)3eE`)zhK-$=lYGKES(su6 z^a=Faf*MZRgFWal0%kbOoxUq1>zG^}j5c@Y8m6YR9Yyf9d3K{uUNh;d`W z(CIcOu=X939Pv#H|Iw10DiuU-KmR?z$_sJE5PTW2VLh(yXfa#3Ce(nT>;8b!Q!=GU zO&5)X0&xbdcU7?WiBdoB`rNKIhdaMuziZGTzZdiq#+Eo|Q34n}_%biPauN7YSZ2b4 z*=yj1Yv+jj_`|pi-}9c|x`rEo`3GPg{<$-sP%ia07cvl2>SXfo&5}Ac)x{8!m2`jz z)9*<+5<&z)jI}1I2K=RrN%GEb-brXB5S;6`sMq+cSjP=iK^{b8UE1~F&i7U(IL6`q zajbxgw;f)Vg_}9)mJziFB*MIHsLDg&TY{YI5o7aa@U?*}$C$$IOlqWW@CGz#rR;-) z-)Gt$tDElJqJ)XJ&4S%{;kB&}84z@gU<;}yR3r;wP{>Li6e*9hy{>}OiY-&;QVrCU z@eZ2gw;4QT77p}dYOYYPrKtSDF;MUsb*N$ zJC@foCo#O~d%g}ek=ucK<8cEp_wkPGZ})7xR?6yws2Yq_rbZ9MR6s^3!mQrOVmF;@ zi5Te6fH0`fpFDVc&hHjNZmi(P`n?)r z0Gxsz21pZ^5P=hIiU})6MdFwNEPK~b_PRWF&qxJI-?|8Yaqz%NieT6;Tz9VC=_!8g z_0X0i(%6h|xoIo)Q?Ota$DzE8eCtEDl}7!&050h@L6{!PuM_pULOu-H(z*iT^?j3i zBV9H`EAv#dlUhyVm@@7oE1=_zvNZTB=yH?>!erJ%MtJITEaH7|= zjsxB6tT|-JwA3hz1z(_bm)vv@x3)~HkbDUlD@V2U5xo{D5mNv?7Do;cyQ}k)D}iHn zv%+UwgWBZ{=h;3N+PmEV%zfO)_Gxm{Tr{2YC);^_k#`1MAPA_x*T*Z(B2*A2 zv0tRwkdisTk}NcdYU#lWy0GdK)I>?!9nZ?W3xH#)8u}XXv0faP{Kt>a_OO-5!yI%l zk9rrV@lB_?77UX;3;-B=c>^o)LC|d;*QHZC=l@ma>_D&Q_vw!}uXhBzbdFW_f76!R z7B+0(!rN_7&VjQJ8(0AY3~y~0>qw>@qNW?5j#7ZibV*=IB?0ES4{R3H<&;5Yt7@r? zF%8-jTkDvg4EZxQ|6^eSKjxd z-|-3>!j=4D?W=HXLc|sG<$avJPVSB0kG}5)VD96y*LZH66P38Gw&APbi%KAr42*Rc zLCDt8C5SIhNzr(o*3u-guVwzb*`%@p73wd7Ej2R%8K1r44O0U!Fh8l)hOWgvcDtY$6O%-QXKT^A+vV}YoM#Ku5 z8zUxK;NV?-sGsYw6ZrVGq9gY!`YSSEigV`EmpuSo7KM2GCAyZBi2>AXd2oHLR^u;> z0#%x1Se$q-oN+YWothuv_}qBbHS|v`iSTlA?N|&#EiVL%b8Qt2hZvBq)zYbrq=~1g z$3LdpFz7iyeYrS#fnskzYQA`MldqZwe#@p@q_-;Ha#}|LBCbDuyMBKa5ObE$?+w7* z$K_Mq(TNs2USMgRYSGE;7i~#hfC`jFsWM$!#=xRkpnpnZ%RsSUiUv%Ql_{S?#a
    x)WP}C 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%0AH5rqFonSV8>Ym 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

    9D|x+4d(yBpTaO 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 Js}Rxk|9@6TaVG!( literal 0 HcmV?d00001 diff --git a/app/Resources/github.png b/app/Resources/github.png new file mode 100644 index 0000000000000000000000000000000000000000..e09d3fd6ea08d727e47ce459cb6280334465a235 GIT binary patch literal 689 zcmV;i0#5yjP)scD)H&@}zvbUH_NyM1A`TG1L=ES3ke+3eS7H0l=>=Q!?`W!WDL!vIaw;B-2{ z;c$S>W&^9$3Kok6D2f8J**qpm^5&Aae#7(pCzs0wEX%?f02qx%Fc=IURVvlhNdOh+ zc^){9lZ!Ja0F%jt0U$~8!_ne`AlwRq00>AV5-=DHAfM06#S!TD`$3W<8AM1fmxF%4 z57B581EAOIuMcgFS`@`G1{#e9;LK(-*laf2&*&L_hf^+>w*Wy9kBW`=csv176afRJ zQVGsYp-|ZU2WUxqfGCPzFn}72w&&dRdOf)~26Q@ILkakfflw#}mnIktZUKTIMoPdO z1DQTN7(2lDWRu(NHk_Mgv-!^{ zQf#u@?S78{uh$E1w_8T)^*St<%Y%his}bsZ{pfKAX+{KkSZ= z3LHTY?oq>v#Ud;g3wh1w^F08e3ILj@$CFN{uXvvSjE0-f=Yw!K46Rn{9N@fhjl*%= zHOsO;Q4gxs>M`KSWHP-|y(Fkv48z=YyWMZI+3b0}UjIgGI-NduI-Rc+Mco~2=&Q*e X3?y>u+RY8^00000NkvXXu0mjfaYrgq literal 0 HcmV?d00001 diff --git a/app/Resources/icon.ico b/app/Resources/icon.ico new file mode 100644 index 0000000000000000000000000000000000000000..910e92fb1f622ff4d3f0d58a47acba2a79c98c60 GIT binary patch literal 32798 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 bk*E-&)$C=;t?DjILBQu==WP3k;LZ341bvbz literal 0 HcmV?d00001 diff --git a/app/Resources/settings.png b/app/Resources/settings.png new file mode 100644 index 0000000000000000000000000000000000000000..2d5d286f2cf6d31a81555c8fd019f3e9d1954482 GIT binary patch literal 357 zcmV-r0h<1aP)(d zSB+;XQ2Yx(3CwC*83VZbAs2s@p^-C40K5Xbs{u^FgKHW9EX-m8qX57oFwwjNtbuQ! zFW(&KrU2d*yE@TCTaEJ+z@2uy2c|$vHk0os^kFQZuUJcX54-@Gz`522wE!G%>z86% zN?s|G55<&C14ckw^Gyg4dW(i$+(5Cp%91I$&EK^46e>|jJO2{dLFzzr{YhKN&9`+a z;@IbYOZqbK={CIp(5(`vqpW4kp1lqHzGw-+;8Sq`!jNQN$i>JW00000NkvXXu0mjf DH64o| literal 0 HcmV?d00001 diff --git a/app/Resources/sync.png b/app/Resources/sync.png new file mode 100644 index 0000000000000000000000000000000000000000..f3aee415991081458f6d85699fd3544ccc23ea90 GIT binary patch literal 366 zcmV-!0g?WRP)dVeX(#!oj#4W^k}mgZl#+pW{{oO8S9+(MznUqBmXu!(cL;u$Ac zL#ZaV8`Eje6(7TqPp+|zC9GgKj1pChB(pe|a>OU_h%3yZy-rLg%3*YiN|phJ@qlCW zW+XF&OT6bA9N;cfd?D6)h&MKfdw;`xGx3D_G_9Zq#fCvG{wL^252RVpSG#|skY`Yi zCq9~Mu!Y66GQ|6%`>VMXq_)4nK!$i9PNVw=a}6pnz@DP?t~#+r%;5(27;lzLtwAY< z-hQ0Z#N3Nfy^NhmAaU66-hUYU`ZO?!)tIiSq8FTD15;VTEeZ|z0RL~|ub{Um5C8xG M07*qoM6N<$g0#Dw$p8QV literal 0 HcmV?d00001 diff --git a/app/Shadow.cs b/app/Shadow.cs new file mode 100644 index 0000000..dd81ec6 --- /dev/null +++ b/app/Shadow.cs @@ -0,0 +1,38 @@ +using System; +using System.Runtime.InteropServices; + +namespace ParsecVDisplay +{ + internal static class Shadow + { + [DllImport("dwmapi.dll")] + static extern int DwmSetWindowAttribute(IntPtr hwnd, int attr, ref int attrValue, int attrSize); + + [StructLayout(LayoutKind.Sequential)] + struct MARGINS + { + public int leftWidth; + public int rightWidth; + public int topHeight; + public int bottomHeight; + } + + [DllImport("dwmapi.dll")] + static extern int DwmExtendFrameIntoClientArea(IntPtr hWnd, ref MARGINS pMarInset); + + public static void ApplyShadow(IntPtr hwnd) + { + var v = 2; + DwmSetWindowAttribute(hwnd, 2, ref v, 4); + + var margins = new MARGINS + { + bottomHeight = 0, + leftWidth = 0, + rightWidth = 0, + topHeight = 1 + }; + DwmExtendFrameIntoClientArea(hwnd, ref margins); + } + } +} \ No newline at end of file diff --git a/app/Tray.cs b/app/Tray.cs new file mode 100644 index 0000000..fa3c25f --- /dev/null +++ b/app/Tray.cs @@ -0,0 +1,84 @@ +using System; +using System.Windows; +using System.Windows.Forms; +using System.Windows.Interop; +using System.Runtime.InteropServices; +using System.Threading; + +namespace ParsecVDisplay +{ + internal static class Tray + { + static NotifyIcon Icon; + static Window Window; + static System.Windows.Controls.ContextMenu Menu; + + public static void Init(Window window, System.Windows.Controls.ContextMenu menu) + { + Window = window; + Menu = menu; + + Icon = new NotifyIcon(); + + var uri = new Uri(window.Icon.ToString()); + var streamInfo = System.Windows.Application.GetResourceStream(uri); + Icon.Icon = new System.Drawing.Icon(streamInfo.Stream); + + Icon.MouseClick += Icon_MouseClick; + Icon.DoubleClick += Icon_DoubleClick; + + Icon.Visible = true; + } + + public static void Uninit() + { + if (Icon != null) + { + Icon.Visible = false; + Icon.Dispose(); + } + } + + private static void Icon_DoubleClick(object sender, EventArgs e) + { + ShowApp(); + } + + private static void Icon_MouseClick(object sender, MouseEventArgs e) + { + if (e.Button == MouseButtons.Right) + { + Menu.IsOpen = true; + + if (PresentationSource.FromVisual(Menu) is HwndSource hwndSource) + { + SetForegroundWindow(hwndSource.Handle); + } + } + } + + public static void ShowApp() + { + if (Window == null) return; + + if (Window.Dispatcher.Thread.ManagedThreadId != Thread.CurrentThread.ManagedThreadId) + { + Window.Dispatcher.BeginInvoke(new Action(ShowApp)); + return; + } + + if (Window.Visibility == Visibility.Hidden) + { + Window.Show(); + } + + if (PresentationSource.FromVisual(Window) is HwndSource hwndSource) + { + SetForegroundWindow(hwndSource.Handle); + } + } + + [DllImport("user32.dll")] + static extern IntPtr SetForegroundWindow(IntPtr hwnd); + } +} \ No newline at end of file diff --git a/app/setup/setup.iss b/app/setup/setup.iss new file mode 100644 index 0000000..e643a4e --- /dev/null +++ b/app/setup/setup.iss @@ -0,0 +1,64 @@ + +#define MyAppName "ParsecVDisplay" +#define MyAppPublisher "Nguyen Duy" +#define MyAppURL "https://github.com/nomi-san/parsec-vdd" +#define MyAppExeName "ParsecVDisplay.exe" +#define MyAppCopyright "© 2024 Nguyen Duy. All rights reserved." + +#define _Major +#define _Minor +#define _Rev +#define _Build +#define VddVersion GetVersionComponents(".\parsec-vdd-setup.exe", _Major, _Minor, _Rev, _Build), Str(_Major) + "." + Str(_Minor) + +[Setup] +AppId={{D2005B5A-A8C4-4B77-807F-155132973D5D} +AppName={#MyAppName} +AppVersion={#VddVersion} +AppVerName={#MyAppName} v{#VddVersion} +AppPublisher={#MyAppPublisher} +AppPublisherURL={#MyAppURL} +AppSupportURL={#MyAppURL} +AppUpdatesURL={#MyAppURL} +VersionInfoCompany={#MyAppPublisher} +VersionInfoCopyright={#MyAppCopyright} +VersionInfoVersion={#VddVersion} +DefaultDirName={commonpf64}\{#MyAppName} +UsePreviousAppDir=yes +DisableProgramGroupPage=yes +LicenseFile=..\..\LICENSE +PrivilegesRequired=admin +OutputDir=.\ +OutputBaseFilename={#MyAppName}-v{#VddVersion}-setup +SetupIconFile=..\Resources\icon.ico +Compression=lzma +SolidCompression=yes +WizardStyle=classic +UninstallDisplayName={#MyAppName} +UninstallDisplayIcon={app}\{#MyAppExeName} + +[Languages] +Name: "english"; MessagesFile: "compiler:Default.isl" + +[Dirs] +Name: "{app}"; Permissions: everyone-full +Name: "{app}\driver-setup"; Permissions: everyone-full + +[Files] +Source: "..\bin\{#MyAppExeName}"; DestDir: "{app}"; Flags: ignoreversion +Source: ".\parsec-vdd-setup.exe"; DestDir: "{app}\driver"; Flags: ignoreversion + +[Icons] +Name: "{autoprograms}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}" +Name: "{autodesktop}\{#MyAppName}"; Filename: "{app}\{#MyAppExeName}" + +[Tasks] +Name: add_startup; Description: "Add program to startup" +Name: install_vdd; Description: "Install Parsec VDD v{#VddVersion}" + +[Run] +Filename: "{app}\{#MyAppExeName}"; Description: "{cm:LaunchProgram,{#StringChange(MyAppName, '&', '&&')}}"; Flags: nowait postinstall skipifsilent runascurrentuser; +Filename: "{app}\driver\parsec-vdd-setup.exe"; Parameters: "/S"; Flags: runascurrentuser; Tasks: install_vdd + +[Registry] +Root: HKCU; Subkey: "SOFTWARE\Microsoft\Windows\CurrentVersion\Run"; ValueType: string; ValueName: "{#MyAppName}"; ValueData: """{app}\{#MyAppExeName}"""; Flags: uninsdeletevalue; Tasks: add_startup \ No newline at end of file