internal static string GetDeviceName(int devNum)
{
DISPLAY_DEVICE d = new DISPLAY_DEVICE(0);
bool result = EnumDisplayDevices(IntPtr.Zero,
devNum, ref d, 0);
return (result ? d.DeviceName.Trim() : "#error#");
}
public static void Win32_SetRefreshRate(uint monitorIndex, uint refreshRate)
{
DISPLAY_DEVICE displayDevice = new DISPLAY_DEVICE();
displayDevice.cb = (ushort)Marshal.SizeOf(displayDevice);
DEVMODE_Display devMode = new DEVMODE_Display();
devMode.dmSize = (ushort)Marshal.SizeOf(devMode);
ChangeDisplaySettings_Result displayResult = ChangeDisplaySettings_Result.DISP_CHANGE_SUCCESSFUL;
int result = EnumDisplayDevices(null, monitorIndex, displayDevice, 0);
if (result != 0)
{
Log.Debug("CycleRefreshRate: Current MonitorIndex : {0} and current deviceName : {1}", (int) monitorIndex,
Manager.Adapters[GUIGraphicsContext.DX9Device.DeviceCaps.AdapterOrdinal].Information.DeviceName);
if (displayDevice.DeviceName != Manager.Adapters[GUIGraphicsContext.DX9Device.DeviceCaps.AdapterOrdinal].Information.DeviceName)
{
// Analyse monitorIndex to be sure to get on the good one (some multiscreen setup can failed otherwise)
monitorIndex = (uint) FindMonitorIndexForScreen();
// Try to get new displayDevice based on newest detected monitorIndex
result = EnumDisplayDevices(null, monitorIndex, displayDevice, 0);
Log.Debug("CycleRefreshRate: New MonitorIndex : {0} based on current deviceName : {1}", (int) monitorIndex,
Manager.Adapters[GUIGraphicsContext.DX9Device.DeviceCaps.AdapterOrdinal].Information.DeviceName);
}
if (result != 0)
{
result = EnumDisplaySettingsEx(displayDevice.DeviceName, 0, devMode, 2);
if (result != 0)
{
result = EnumDisplaySettingsEx(displayDevice.DeviceName, EnumDisplaySettings_EnumMode.ENUM_CURRENT_SETTINGS, devMode, 2); // EDS_RAWMODE = 2
if (result != 0)
{
// Get current Value
uint Width = devMode.dmPelsWidth;
uint Height = devMode.dmPelsHeight;
//Log.Info("CycleRefreshRate: code result {0} enum devMode", result);
devMode.dmFields = (DEVMODE_Fields.DM_BITSPERPEL | DEVMODE_Fields.DM_PELSWIDTH |
DEVMODE_Fields.DM_PELSHEIGHT | DEVMODE_Fields.DM_DISPLAYFREQUENCY);
devMode.dmBitsPerPel = 32;
devMode.dmPelsWidth = Width;
devMode.dmPelsHeight = Height;
devMode.dmDisplayFrequency = refreshRate;
// First set settings
ChangeDisplaySettings_Result r = ChangeDisplaySettingsEx(displayDevice.DeviceName, devMode,
IntPtr.Zero,
(ChangeDisplaySettings_Flags
.CDS_NORESET |
ChangeDisplaySettings_Flags
.CDS_UPDATEREGISTRY),
IntPtr.Zero);
if (r != displayResult)
{
Log.Info("CycleRefreshRate: unable to change refresh rate {0}Hz for monitor {1}", refreshRate, monitorIndex);
}
else
{
// Apply settings
r = ChangeDisplaySettingsEx(null, null, IntPtr.Zero, 0, IntPtr.Zero);
Log.Info("CycleRefreshRate: result {0} for refresh rate change {1}Hz", r, refreshRate);
FixDwm();
}
}
}
}
}
else
{
Log.Info("CycleRefreshRate: unable to change refresh rate {0}Hz for monitor {1}", refreshRate, monitorIndex);
}
}
public static extern bool EnumDisplayDevices(string lpDevice, int iDevNum, ref DISPLAY_DEVICE lpDisplayDevice, int dwFlags);
internal static bool MainDevice(int devNum)
{
//whether the specified device is the main device
DISPLAY_DEVICE d = new DISPLAY_DEVICE(0);
if (EnumDisplayDevices(IntPtr.Zero, devNum, ref d, 0))
{
return ((d.StateFlags & 4) != 0);
}
return false;
}
public static string DeviceToString(DISPLAY_DEVICE device)
{
string item = device.DeviceString.Trim();
if ((device.StateFlags & 4) != 0) item += " - main";
return item;
}
private static void EnumDevices()
{
//populates Display Devices list
Devices = new List<DISPLAY_DEVICE>();
DISPLAY_DEVICE d = new DISPLAY_DEVICE(0);
int devNum = 0;
bool result;
while (result = EnumDisplayDevices(IntPtr.Zero, devNum, ref d, 0))
{
Devices.Add(d);
devNum++;
}
}
public override void LoadSettings()
{
int indexAdapter = 0;
DataTable dtblDataSource = new DataTable();
dtblDataSource.Columns.Add("DisplayMember");
dtblDataSource.Columns.Add("ValueMember");
dtblDataSource.Columns.Add("AdditionalInfo");
dtblDataSource.Columns.Add("MonitorDisplayName");
cbScreen.DataSource.SafeDispose();
cbScreen.Items.Clear();
cbScreen.DataSource = dtblDataSource;
cbScreen.DisplayMember = "DisplayMember";
cbScreen.ValueMember = "ValueMember";
foreach (Screen screen in Screen.AllScreens)
{
const int dwf = 0;
var info = new DISPLAY_DEVICE();
string monitorname = null;
string deviceId = null;
info.cb = Marshal.SizeOf(info);
if (EnumDisplayDevices(screen.DeviceName, 0, ref info, dwf))
{
monitorname = info.DeviceString;
deviceId = info.DeviceID;
}
if (monitorname == null)
{
monitorname = "";
}
if (deviceId == null)
{
deviceId = "";
}
foreach (AdapterInformation adapter in Manager.Adapters)
{
bool detectedId = false;
if (screen.DeviceName.Equals(adapter.Information.DeviceName.Trim()))
{
foreach (var display in DisplayDetails.GetMonitorDetails())
{
// double check to add display with name from extracted EDID
if (("MONITOR" + "\\" + display.MonitorID + "\\" + display.DriverID).Equals(info.DeviceID))
{
if (!string.IsNullOrEmpty(display.Model))
{
dtblDataSource.Rows.Add(string.Format("{0} ({1}x{2}) on {3} - Screen Primary : {4}", display.Model,
adapter.CurrentDisplayMode.Width, adapter.CurrentDisplayMode.Height, adapter.Information.Description, screen.Primary ? "Yes" : "No"),
indexAdapter, info.DeviceID, adapter.Information.DeviceName.Trim());
indexAdapter++;
detectedId = true;
break;
}
dtblDataSource.Rows.Add(string.Format("{0} ({1}x{2}) on {3} - Screen Primary : {4}", monitorname,
adapter.CurrentDisplayMode.Width, adapter.CurrentDisplayMode.Height, adapter.Information.Description, screen.Primary ? "Yes" : "No"),
indexAdapter, info.DeviceID, adapter.Information.DeviceName.Trim());
indexAdapter++;
detectedId = true;
break;
}
}
if (!detectedId)
{
dtblDataSource.Rows.Add(string.Format("{0} ({1}x{2}) on {3} - Screen Primary : {4}", monitorname,
adapter.CurrentDisplayMode.Width, adapter.CurrentDisplayMode.Height, adapter.Information.Description, screen.Primary ? "Yes" : "No"),
indexAdapter, deviceId, adapter.Information.DeviceName.Trim());
indexAdapter++;
break;
}
}
}
}
using (Settings xmlreader = new MPSettings())
{
// Load general settings
for (int index = 0; index < _sectionEntries.Length; index++)
{
string[] currentSection = _sectionEntries[index];
settingsCheckedListBox.SetItemChecked(index, xmlreader.GetValueAsBool(currentSection[0], currentSection[1], bool.Parse(currentSection[2])));
}
_screennumber = xmlreader.GetValueAsInt("screenselector", "screennumber", 0);
_screenDeviceId = xmlreader.GetValueAsString("screenselector", "screendeviceid", "");
_usePrimaryScreen = xmlreader.GetValueAsBool("general", "useprimaryscreen", false);
while (cbScreen.Items.Count <= _screennumber)
{
dtblDataSource.Rows.Add("screen nr :" + cbScreen.Items.Count + " (currently unavailable)");
}
for (int index = 0; index < cbScreen.Items.Count; index++)
{
//Get additional info for selected item
var dataRowView = cbScreen.Items[index] as DataRowView;
if (dataRowView != null)
{
string screenDeviceId = dataRowView["AdditionalInfo"].ToString();
if (screenDeviceId.Equals(_screenDeviceId))
{
cbScreen.SelectedIndex = index;
_screennumber = index;
}
}
}
// Check if screen are present and if not force to use primary screen
if (cbScreen.SelectedIndex == -1)
{
cbScreen.SelectedIndex = 0;
}
if (_usePrimaryScreen)
{
cbScreen.Enabled = false;
}
nudDelay.Value = xmlreader.GetValueAsInt("general", "delay", 0);
mpCheckBoxMpStartup.Checked = xmlreader.GetValueAsBool("general", "delay startup", false);
mpCheckBoxMpResume.Checked = xmlreader.GetValueAsBool("general", "delay resume", false);
}
// On single seat WaitForTvService is forced enabled !
cbWaitForTvService.Checked = Network.IsSingleSeat();
}
public void GetScreens()
{
_screenCollection.Clear();
foreach (Screen screen in Screen.AllScreens)
{
const int dwf = 0;
var info = new DISPLAY_DEVICE();
string monitorname = null;
string deviceId = null;
info.cb = Marshal.SizeOf(info);
if (EnumDisplayDevices(screen.DeviceName, 0, info, dwf))
{
monitorname = info.DeviceString;
deviceId = info.DeviceID;
}
if (monitorname == null)
{
monitorname = "";
}
if (deviceId == null)
{
deviceId = "";
}
foreach (AdapterInformation adapter in Manager.Adapters)
{
bool detectedId = false;
if (screen.DeviceName.Equals(adapter.Information.DeviceName.Trim()))
{
foreach (var display in DisplayDetails.GetMonitorDetails())
{
// double check to add display with name from extracted EDID
if (("MONITOR" + "\\" + display.MonitorID + "\\" + display.DriverID).Equals(info.DeviceID))
{
_screenCollection.Add(
new Tuple<string, string, string>((
string.Format("{0} ({1}x{2}) on {3}", display.Model, adapter.CurrentDisplayMode.Width,
adapter.CurrentDisplayMode.Height, adapter.Information.Description)), deviceId, adapter.Information.DeviceName.Trim()));
detectedId = true;
break;
}
}
if (!detectedId)
{
_screenCollection.Add(
new Tuple<string, string, string>((
string.Format("{0} ({1}x{2}) on {3}", monitorname, adapter.CurrentDisplayMode.Width,
adapter.CurrentDisplayMode.Height, adapter.Information.Description)), deviceId, adapter.Information.DeviceName.Trim()));
break;
}
}
}
}
}
public static DISPLAY_DEVICE[] GetDisplays()
{
var displays = new System.Collections.Generic.List<DISPLAY_DEVICE>();
DISPLAY_DEVICE d = new DISPLAY_DEVICE();
d.cb = 840;
for (uint id = 0; GetDisplay(id, 0, ref d); id++)
{
//System.Diagnostics.Debug.WriteLine(
// String.Format("{0}, {1}, {2}, {3}, {4}, {5}",
// id,
// d.DeviceName,
// d.DeviceString,
// d.StateFlags,
// d.DeviceID,
// d.DeviceKey
// )
// );
displays.Add(d);
d = new DISPLAY_DEVICE();
d.cb = 840;
}
return displays.ToArray();
}
public static DisplayInfo GetDisplayDevices()
{
DisplayInfo displayDevices = new DisplayInfo();
Match match;
DISPLAY_DEVICE d = new DISPLAY_DEVICE();
d.cb = Marshal.SizeOf(d);
for (uint id = 0; EnumDisplayDevices(null, id, ref d, 0); id++)
{
if (d.StateFlags.HasFlag(DisplayDeviceStateFlags.AttachedToDesktop))
{
d.cb = Marshal.SizeOf(d);
EnumDisplayDevices(d.DeviceName, 0, ref d, 0);
if ((match = new Regex(@"^MONITOR\\(.*?)\\").Match(d.DeviceID)).Success)
{
var deviceID = match.Groups[1].Value;
if (deviceID == "Default_Monitor") deviceID += getComputerID();
displayDevices.devices.Add(new DisplayDeviceInfo() { DeviceString = d.DeviceString, DeviceID = deviceID, Scaling = getDeviceScaling(deviceID) });
}
}
d.cb = Marshal.SizeOf(d);
}
return displayDevices;
}
internal static extern bool EnumDisplayDevices([MarshalAs(UnmanagedType.LPTStr)] string lpDevice, int iDevNum, ref DISPLAY_DEVICE lpDisplayDevice, int dwFlags);
private void getDisplayMode_EnumDisplaySettings(int numDisplay)
{
DISPLAY_DEVICE display_DEVICE = default(DISPLAY_DEVICE);
display_DEVICE.cb = Marshal.SizeOf(display_DEVICE);
List <string> list = new List <string>();
MainWindow.MonitorInfoEx[] monitors = MainWindow.GetMonitors();
uint num = 0u;
while (MainWindow.EnumDisplayDevices(null, num, ref display_DEVICE, 1u))
{
if ((display_DEVICE.StateFlags & DisplayDeviceStateFlags.AttachedToDesktop) == DisplayDeviceStateFlags.AttachedToDesktop)
{
list.Add(display_DEVICE.DeviceName);
}
num += 1u;
}
int num2 = 0;
int num3 = -1;
foreach (string text in list)
{
int num4 = 0;
int num5 = 0;
DEVMODE devmode = default(DEVMODE);
List <MainWindow.DisplayMode> list2 = new List <MainWindow.DisplayMode>();
int num6 = 0;
while (MainWindow.EnumDisplaySettings(text, num6, ref devmode))
{
int nXX = devmode.dmPelsWidth;
int nYY = devmode.dmPelsHeight;
if ((num4 != nXX || num5 != nYY) && devmode.dmBitsPerPel == 32)
{
MainWindow.DisplayMode displayMode = this.m_listDefaultDisplay.Find((MainWindow.DisplayMode dis) => dis.Width == nXX && dis.Height == nYY);
if (displayMode.Width != 0)
{
list2.Add(displayMode);
}
num4 = nXX;
num5 = nYY;
}
num6++;
}
MainWindow.DisplayModes item = default(MainWindow.DisplayModes);
foreach (MainWindow.MonitorInfoEx monitorInfoEx in monitors)
{
if (monitorInfoEx.szDevice == text)
{
item.x = monitorInfoEx.rcWork.Left;
item.y = monitorInfoEx.rcWork.Top;
if (monitorInfoEx.dwFlags == 1)
{
num3 = num2;
}
}
}
item.list = list2;
num2++;
this.m_listCurrentDisplay.Add(item);
}
if (this.m_listCurrentDisplay.Count == 0 || this.m_listCurrentDisplay.Count != numDisplay)
{
System.Windows.Forms.MessageBox.Show("Failed to list supported resolutions");
}
this.m_listCurrentDisplay.Insert(0, this.m_listCurrentDisplay[num3]);
this.m_listCurrentDisplay.RemoveAt(num3 + 1);
}
public DisplayDevice(IUser32 user32, int index, DISPLAY_DEVICE displayDevice)
{
_user32 = user32;
_index = index;
_displayDevice = displayDevice;
}
public static DISPLAY_DEVICE CreateDISPLAY_DEVICE()
{
DISPLAY_DEVICE dd = new DISPLAY_DEVICE();
dd.DeviceName = new String( new char[32] );
dd.DeviceString = new String( new char[128] );
dd.DeviceID = new String( new char[128] );
dd.DeviceKey = new String( new char[128] );
dd.cb = (int)Marshal.SizeOf( dd );
return dd;
}
public IEnumerable <DetailedScreen> GetScreens()
{
var screens = new List <DetailedScreen>();
int index = 1;
var d = new DISPLAY_DEVICE();
d.cb = Marshal.SizeOf(d);
try
{
for (uint id = 0; EnumDisplayDevices(null, id, ref d, 0); id++)
{
d.cb = Marshal.SizeOf(d);
var x = new DISPLAY_DEVICE();
x.cb = Marshal.SizeOf(x);
//Get the actual monitor
EnumDisplayDevices(d.DeviceName, 0, ref x, 0);
if (string.IsNullOrEmpty(x.DeviceName) || string.IsNullOrEmpty(x.DeviceString))
{
continue;
}
var screen = new DetailedScreen {
FriendlyName = x.DeviceString, Index = index++
};
var mode = new DEVMODE();
mode.dmSize = (ushort)Marshal.SizeOf(mode);
if (EnumDisplaySettings(d.DeviceName, -1, ref mode))
{
screen.Width = (int)mode.dmPelsWidth;
screen.Height = (int)mode.dmPelsHeight;
screen.Top = mode.dmPosition.y;
screen.Left = mode.dmPosition.x;
}
screens.Add(screen);
}
}
catch (Exception)
{
//log this
}
var biggestScreen = screens.OrderByDescending(s => s.Width).FirstOrDefault();
if (biggestScreen != null)
{
var maxWidth = biggestScreen.Width;
foreach (var s in screens)
{
s.RelativeWidth = 200 * (s.Width / maxWidth);
s.RelativeHeight = s.RelativeWidth * (s.Height / s.Width);
s.Top *= (s.RelativeHeight / s.Height);
}
}
screens = screens.OrderBy(s => s.Left).ToList();
return(screens);
}
/// <summary>
///
/// </summary>
public MediaPortalApp()
{
// init attributes
_xpos = 50;
_lastOnresume = DateTime.Now;
_updateTimer = DateTime.MinValue;
_lastContextMenuAction = DateTime.MaxValue;
_region = new Rectangle[1];
_restartOptions = RestartOptions.Reboot;
int screenNumber;
string screenDeviceId;
using (Settings xmlreader = new MPSettings())
{
_suspendGracePeriodSec = xmlreader.GetValueAsInt("general", "suspendgraceperiod", 5);
_useScreenSaver = xmlreader.GetValueAsBool("general", "IdleTimer", true);
_timeScreenSaver = xmlreader.GetValueAsInt("general", "IdleTimeValue", 300);
_useIdleblankScreen = xmlreader.GetValueAsBool("general", "IdleBlanking", false);
_useIdlePluginScreen = xmlreader.GetValueAsBool("general", "IdlePlugin", false);
_idlePluginWindowId = xmlreader.GetValueAsInt("general", "IdlePluginWindow", 0);
_showLastActiveModule = xmlreader.GetValueAsBool("general", "showlastactivemodule", false);
screenNumber = xmlreader.GetValueAsInt("screenselector", "screennumber", 0);
_stopOnLostAudioRenderer = xmlreader.GetValueAsBool("general", "stoponaudioremoval", true);
_delayOnResume = xmlreader.GetValueAsBool("general", "delay resume", false) ? xmlreader.GetValueAsInt("general", "delay", 0) : 0;
screenDeviceId = xmlreader.GetValueAsString("screenselector", "screendeviceid", "");
_usePrimaryScreen = xmlreader.GetValueAsBool("general", "useprimaryscreen", false);
_screenDisplayName = xmlreader.GetValueAsString("screenselector", "screendisplayname", "");
}
if (ScreenNumberOverride >= 0)
{
screenNumber = ScreenNumberOverride;
if (screenNumber < 0 || screenNumber >= Screen.AllScreens.Length)
{
screenNumber = 0;
}
GUIGraphicsContext.currentScreen = Screen.AllScreens[screenNumber];
}
else
{
bool foundScreen = false;
foreach (Screen screen in Screen.AllScreens)
{
const int dwf = 0;
var info = new DISPLAY_DEVICE();
string monitorname = null;
string deviceId = null;
info.cb = Marshal.SizeOf(info);
if (EnumDisplayDevices(screen.DeviceName, 0, info, dwf))
{
monitorname = info.DeviceString;
deviceId = info.DeviceID;
}
if (monitorname == null)
{
monitorname = "";
}
if (deviceId == null)
{
deviceId = "";
}
if (_usePrimaryScreen)
{
if (screen.Primary)
{
GUIGraphicsContext.currentScreen = screen;
foundScreen = true;
break;
}
}
else
{
if (!string.IsNullOrEmpty(deviceId))
{
if (deviceId.Equals(screenDeviceId))
{
GUIGraphicsContext.currentScreen = screen;
foundScreen = true;
break;
}
}
else
{
if (screen.DeviceName.Equals(_screenDisplayName))
{
GUIGraphicsContext.currentScreen = screen;
foundScreen = true;
break;
}
}
}
}
if (!foundScreen)
{
GUIGraphicsContext.currentScreen = screenNumber >= Screen.AllScreens.Length ? Screen.AllScreens[0] : Screen.AllScreens[screenNumber];
}
}
Log.Info("Main: MP is using screen: {0} (Position: {1},{2} Dimensions: {3}x{4})",
GetCleanDisplayName(GUIGraphicsContext.currentScreen),
GUIGraphicsContext.currentScreen.Bounds.Location.X, GUIGraphicsContext.currentScreen.Bounds.Location.Y,
GUIGraphicsContext.currentScreen.Bounds.Width, GUIGraphicsContext.currentScreen.Bounds.Height);
// move form to selected screen
Location = new Point(Location.X + GUIGraphicsContext.currentScreen.Bounds.X, Location.Y + GUIGraphicsContext.currentScreen.Bounds.Y);
// temporarily set new client size for initialization purposes
ClientSize = new Size(0, 0);
// check if MediaPortal is already running...
Log.Info("Main: Checking for running MediaPortal instance");
Log.Info(@"Main: Deleting old log\capture.log");
Utils.FileDelete(Config.GetFile(Config.Dir.Log, "capture.log"));
// ReSharper disable LocalizableElement
Text = "MediaPortal";
// ReSharper restore LocalizableElement
GUIGraphicsContext.form = this;
GUIGraphicsContext.graphics = null;
GUIGraphicsContext.RenderGUI = this;
GUIGraphicsContext.Render3DMode = GUIGraphicsContext.eRender3DMode.None;
GUIGraphicsContext.DeviceAudioConnected = 0;
GUIGraphicsContext.DeviceVideoConnected = 0;
using (Settings xmlreader = new MPSettings())
{
AutoHideMouse = xmlreader.GetValueAsBool("general", "autohidemouse", true);
GUIGraphicsContext.MouseSupport = xmlreader.GetValueAsBool("gui", "mousesupport", false);
GUIGraphicsContext.AllowRememberLastFocusedItem = xmlreader.GetValueAsBool("gui", "allowRememberLastFocusedItem", false);
GUIGraphicsContext.DBLClickAsRightClick = xmlreader.GetValueAsBool("general", "dblclickasrightclick", false);
MinimizeOnStartup = xmlreader.GetValueAsBool("general", "minimizeonstartup", false);
MinimizeOnGuiExit = xmlreader.GetValueAsBool("general", "minimizeonexit", false);
MinimizeOnFocusLoss = xmlreader.GetValueAsBool("general", "minimizeonfocusloss", false);
}
SetStyle(ControlStyles.Opaque, true);
SetStyle(ControlStyles.UserPaint, true);
SetStyle(ControlStyles.AllPaintingInWmPaint, true);
SetStyle(ControlStyles.DoubleBuffer, false);
Activated += MediaPortalAppActivated;
Deactivate += MediaPortalAppDeactivate;
Log.Info("Main: Checking skin version");
CheckSkinVersion();
using (Settings xmlreader = new MPSettings())
{
_keepstartfullscreen = xmlreader.GetValueAsBool("general", "keepstartfullscreen", false);
var startFullscreen = !WindowedOverride && (FullscreenOverride || xmlreader.GetValueAsBool("general", "startfullscreen", false));
if (_keepstartfullscreen)
{
Windowed = !_keepstartfullscreen;
}
else
{
Windowed = !startFullscreen;
}
}
DoStartupJobs();
}
public static bool GetDisplay(uint id, uint flags, ref DISPLAY_DEVICE device)
{
var val = DllImportCaller.lib.EnumDisplayDevices7(id, ref device, flags);
return val != 0;
}
public CaptureSelection()
{
InitializeComponent();
//Oculus code
if (OculusClient.isHMDPresent() == true)
{
detectedLabel.Text = "Rift Detected; Data should be valid.";
//Scan oculus angles. I store them in a Vector3 with 3 values for each axis.
//It's a quaternion, so I convert it to Euler angles (X, Y, Z)
Vector3 oculusAngles = Helpers.ToEulerAngles(OculusClient.GetPredictedOrientation());
//Format the float angles and send them to the labels
XLabel.Text = String.Format("{0:0,0.0000000}", oculusAngles.X);
YLabel.Text = String.Format("{0:0,0.0000000}", oculusAngles.Y);
ZLabel.Text = String.Format("{0:0,0.0000000}", oculusAngles.Z);
//Scan Oculus's resolution and format it
Vector2 oculusResolution = OculusClient.GetScreenResolution();
resolutionLabel.Text = String.Format(oculusResolution.X + "x" + oculusResolution.Y);
}
else
{
detectedLabel.Text = "No Rift Detected; Data is invalid.";
}
//Scott's code
var screens = System.Windows.Forms.Screen.AllScreens;
var mapInstanceToUserFriendly = new Dictionary<string, string>();
try
{
ManagementObjectSearcher searcher = new ManagementObjectSearcher("root\\WMI", "SELECT * FROM WmiMonitorID");
foreach (ManagementObject queryObj in searcher.Get())
{
string instanceName = (string)queryObj["InstanceName"];
string userFriendlyName = "";
if ((instanceName != null) && (queryObj["UserFriendlyName"] != null))
{
UInt16[] arrUserFriendlyName = (UInt16[])(queryObj["UserFriendlyName"]);
foreach (UInt16 arrValue in arrUserFriendlyName)
{
if (arrValue == 0) break;
userFriendlyName += Convert.ToChar(arrValue);
}
instanceName = instanceName.Replace('\\', '#');
string[] splitInstance = instanceName.Split('_');
if ((splitInstance != null) && (splitInstance.Length >= 1))
{
instanceName = splitInstance[0];
mapInstanceToUserFriendly[instanceName] = userFriendlyName;
}
}
}
}
catch (ManagementException e)
{
MessageBox.Show("An error occurred while querying for WMI data: " + e.Message + ". Exiting.", "Ocucam - Error");
Environment.Exit(-1);
}
var mapIdsToDisplay = new Dictionary<int, Display>();
DISPLAY_DEVICE d = new DISPLAY_DEVICE();
d.cb = Marshal.SizeOf(d);
try
{
for (int id = 0; EnumDisplayDevices(null, (uint)id, ref d, 0); id++)
{
string name = d.DeviceName;
d.cb = Marshal.SizeOf(d);
EnumDisplayDevices(name, 0, ref d, EDD_GET_DEVICE_INTERFACE_NAME);
foreach (string instanceName in mapInstanceToUserFriendly.Keys)
{
if (d.DeviceID.Contains(instanceName))
{
mapIdsToDisplay[id] = new Display(id, mapInstanceToUserFriendly[instanceName], instanceName);
break;
}
}
d.cb = Marshal.SizeOf(d);
}
}
catch (Exception ex)
{
MessageBox.Show("Error enumerating display devices. Exiting.", "Ocucam - Error");
Environment.Exit(-1);
}
DSVideoCaptureCategory captureCategory = new DSVideoCaptureCategory();
if (captureCategory.Objects.Count < 2)
{
if (captureCategory.Objects.Count == 0)
{
MessageBox.Show("System must have at least two distinct video capture devices. None were found. Exiting.", "Ocucam - Error");
}
else
{
MessageBox.Show("System must have at least two distinct video capture devices. Only one was found. Exiting.", "Ocucam - Error");
}
Environment.Exit(-1);
}
RegistryKey softwareKey = Registry.CurrentUser.OpenSubKey("Software", true);
RegistryKey scottCutlerKey = softwareKey.CreateSubKey("Scott Cutler");
RegistryKey ocucamKey = scottCutlerKey.CreateSubKey("Ocucam");
string leftEyeDevicePathReg = (string)ocucamKey.GetValue("leftEyeDevicePath", "");
string rightEyeDevicePathReg = (string)ocucamKey.GetValue("rightEyeDevicePath", "");
string displayDeviceInstanceReg = (string)ocucamKey.GetValue("displayDeviceInstance", "");
checkBoxFullScreen.Checked = ((string)ocucamKey.GetValue("fullScreen", "True") == "True") ? true : false;
ocucamKey.Close();
scottCutlerKey.Close();
softwareKey.Close();
captureCategory.Objects.Sort((a, b) => { return a.DevicePath.CompareTo(b.DevicePath); });
var objectCount = new Dictionary<string, int>();
foreach (var captureDevice in captureCategory.Objects)
{
if (objectCount.ContainsKey(captureDevice.DevicePath))
{
objectCount[captureDevice.DevicePath]++;
}
else
{
objectCount.Add(captureDevice.DevicePath, 1);
}
DSDeviceWrap dw = new DSDeviceWrap(captureDevice, objectCount[captureDevice.DevicePath]);
leftEyeDevice.Items.Add(dw);
if (leftEyeDevicePathReg == captureDevice.DevicePath)
{
leftEyeDevice.SelectedIndex = leftEyeDevice.Items.Count - 1;
}
rightEyeDevice.Items.Add(dw);
if (rightEyeDevicePathReg == captureDevice.DevicePath)
{
rightEyeDevice.SelectedIndex = rightEyeDevice.Items.Count - 1;
}
}
foreach (var displayId in mapIdsToDisplay.Keys)
{
comboBoxDisplay.Items.Add(mapIdsToDisplay[displayId]);
if (displayDeviceInstanceReg == mapIdsToDisplay[displayId].instance)
{
comboBoxDisplay.SelectedIndex = comboBoxDisplay.Items.Count - 1;
}
}
}
public static DISPLAY_DEVICE GetDisplay(uint id, uint flags)
{
DISPLAY_DEVICE dev = new DISPLAY_DEVICE();
dev.cb = 840;
var display = GetDisplay(id, flags, ref dev);
return dev;
}
// PLEASE NOTE: when adding items, adjust the box so it doesn't get scrollbars
// AND be careful cause depending on where you add a setting, the indexes might have changed!!!
public override void LoadSettings()
{
cbScreen.Items.Clear();
foreach (Screen screen in Screen.AllScreens)
{
const int dwf = 0;
var info = new DISPLAY_DEVICE();
string monitorname = null;
info.cb = Marshal.SizeOf(info);
if (EnumDisplayDevices(screen.DeviceName, 0, info, dwf))
{
monitorname = info.DeviceString;
}
if (monitorname == null)
{
monitorname = "";
}
foreach (AdapterInformation adapter in Manager.Adapters)
{
if (screen.DeviceName.StartsWith(adapter.Information.DeviceName.Trim()))
{
cbScreen.Items.Add(string.Format("{0} ({1}x{2}) on {3}", monitorname, adapter.CurrentDisplayMode.Width, adapter.CurrentDisplayMode.Height, adapter.Information.Description));
}
}
}
using (Settings xmlreader = new MPSettings())
{
// Load general settings
for (int index = 0; index < _sectionEntries.Length; index++)
{
string[] currentSection = _sectionEntries[index];
settingsCheckedListBox.SetItemChecked(index, xmlreader.GetValueAsBool(currentSection[0], currentSection[1], bool.Parse(currentSection[2])));
}
_screennumber = xmlreader.GetValueAsInt("screenselector", "screennumber", 0);
while (cbScreen.Items.Count <= _screennumber)
{
cbScreen.Items.Add("screen nr :" + cbScreen.Items.Count + " (currently unavailable)");
}
cbScreen.SelectedIndex = _screennumber;
nudDelay.Value = xmlreader.GetValueAsInt("general", "delay", 0);
mpCheckBoxMpStartup.Checked = xmlreader.GetValueAsBool("general", "delay startup", false);
mpCheckBoxMpResume.Checked = xmlreader.GetValueAsBool("general", "delay resume", false);
}
// On single seat WaitForTvService is forced enabled !
cbWaitForTvService.Checked = Network.IsSingleSeat();
}
public static List<DISPLAY_DEVICE> GetScreens()
{
DISPLAY_DEVICE vDevice = new DISPLAY_DEVICE();
vDevice.cb = Marshal.SizeOf(vDevice);
List<DISPLAY_DEVICE> list = new List<DISPLAY_DEVICE>();
uint i = 0;
while (EnumDisplayDevices(null, i, ref vDevice, 0))
{
if (vDevice.StateFlags.HasFlag(DisplayDeviceStateFlags.AttachedToDesktop))
list.Add(vDevice);
i++;
vDevice.cb = Marshal.SizeOf(vDevice);
}
return list;
}
private static extern bool EnumDisplayDevices( IntPtr lpDevice, int iDevNum, ref DISPLAY_DEVICE lpDisplayDevice, int dwFlags);
internal static extern UInt32 EnumDisplayDevices(string s, UInt32 iDevNum, ref DISPLAY_DEVICE displayDevice, UInt32 dwFlags);
private static extern bool EnumDisplayDevices(string DeviceID, [MarshalAs(UnmanagedType.U4)] int DeviceIndex, ref DISPLAY_DEVICE DisplayDevice, int Flags);
static void SetResolution(string[] args)
{
string deviceName = null;
int width = 0;
int height = 0;
short bits = 0;
int frequency = 0;
OptionSet p = new OptionSet()
{
{
"d|device=", "the {NAME} of the screen device.",
v => deviceName = v
},
{
"w|width=", "the display resolution {WIDTH} in pixels.",
(int v) => width = v
},
{
"h|height=", "the display resolution {HEIGHT} in pixels.",
(int v) => height = v
},
{
"b|bits=", "the display resolution {BITS}.",
(short v) => bits = v
},
{
"f|frequency=", "the display resolution {FREQUENCY} in hertz.",
(short v) => bits = v
}
};
List <string> extra;
try
{
extra = p.Parse(args);
}
catch (OptionException e)
{
Console.WriteLine("ERROR: " + e.Message);
return;
}
if (deviceName == null)
{
Console.WriteLine("ERROR: No device name has not been specified.");
return;
}
if (width <= 0)
{
Console.WriteLine("ERROR: Invalid width specified.");
return;
}
if (height <= 0)
{
Console.WriteLine("ERROR: Invalid height specified.");
return;
}
try
{
DISPLAY_DEVICE d = ScreenDevice.GetDesktopDeviceByName(deviceName);
if (frequency > 0 && bits > 0)
{
ScreenDevice.ChangeResolution(ref d, width, height, bits, frequency);
}
else if (bits > 0)
{
ScreenDevice.ChangeResolution(ref d, width, height, bits);
}
else
{
ScreenDevice.ChangeResolution(ref d, width, height);
}
}
catch (User32Exception e)
{
Console.WriteLine("ERROR: " + e.Message);
return;
}
}
static void updateScreen()
{
int display_num = 0;
string data, path;
DISPLAY_DEVICE d = new DISPLAY_DEVICE();
d.cb = Marshal.SizeOf(d);
// loop for all available displays
foreach (var screen in Screen.AllScreens)
{
EnumDisplayDevices(null, (uint)display_num, ref d, 0);
// write display name
data = d.DeviceString;
//data = screen.DeviceName;
path = "display/activeAdapter/" + display_num;
hostService.XenStoreWrite(path, data);
// write resolution
data = screen.Bounds.Width + " " + screen.Bounds.Height;
path = "display/activeAdapter/" + display_num + "/resolution";
hostService.XenStoreWrite(path, data);
// write position
data = screen.Bounds.X + " " + screen.Bounds.Y;
path = "display/activeAdapter/" + display_num + "/position";
hostService.XenStoreWrite(path, data);
display_num++;
}
// write number of total active adapters at the root node
data = display_num.ToString();
path = "display/activeAdapter";
hostService.XenStoreWrite(path, data);
// write virtual screen size
data = SystemInformation.VirtualScreen.Width + " " + SystemInformation.VirtualScreen.Height;
path = "attr/desktopDimensions";
hostService.XenStoreWrite(path, data);
}
static void RestoreCurrentResolution(string[] args)
{
string profileName = "Default";
bool silent = false;
OptionSet p = new OptionSet()
{
{
"p|profile=", "the {PROFILENAME} of the screen resolution. (\"Default\" is the default profile.)",
v => profileName = RegistryHandler.sanitizeProfileName(v)
},
{
"q|quiet", "be quiet",
v => silent = v != null
}
};
List <string> extra;
try
{
extra = p.Parse(args);
}
catch (OptionException e)
{
if (!silent)
{
Console.WriteLine("ERROR: " + e.Message);
}
return;
}
foreach (RegistryProfileDeviceSettings rpds in RegistryHandler.getProfile(profileName))
{
try
{
if (!silent)
{
Console.WriteLine("Restoring Screen resolution: " + rpds);
}
DISPLAY_DEVICE d = ScreenDevice.GetDesktopDeviceByName(rpds.DeviceName);
if (rpds.Frequency > 0 && rpds.Bits > 0)
{
try
{
ScreenDevice.ChangeResolution(ref d, rpds.Width, rpds.Height, rpds.Bits, rpds.Frequency);
}
catch (User32Exception)
{
rpds.Frequency = 0;
if (!silent)
{
Console.WriteLine("Failed to change resolution, restoring without frequency: " + rpds);
}
ScreenDevice.ChangeResolution(ref d, rpds.Width, rpds.Height, rpds.Bits);
}
}
else if (rpds.Bits > 0)
{
ScreenDevice.ChangeResolution(ref d, rpds.Width, rpds.Height, rpds.Bits);
}
else
{
ScreenDevice.ChangeResolution(ref d, rpds.Width, rpds.Height);
}
}
catch (Exception e)
{
if (!silent)
{
Console.WriteLine("ERROR: " + e.Message);
}
}
}
if (!silent)
{
Console.WriteLine("Screen resolution has been restored from profile \"" + profileName + "\".");
}
}
/// <summary>
/// Finds the monitorIndex based on current specified screen on its primary monitor
/// </summary>
/// <returns>The monitorIndex that has the specified screen on its primary monitor</returns>
protected static int FindMonitorIndexForScreen()
{
uint deviceNum = 0;
DISPLAY_DEVICE displayDevice = new DISPLAY_DEVICE();
displayDevice.cb = (ushort)Marshal.SizeOf(displayDevice);
while (EnumDisplayDevices(null, deviceNum, displayDevice, 0) != 0)
{
if (displayDevice.DeviceName == Manager.Adapters[GUIGraphicsContext.DX9Device.DeviceCaps.AdapterOrdinal].Information.DeviceName)
{
// Set new monitorIndex
GUIGraphicsContext.currentMonitorIdx = (int)deviceNum;
Log.Debug("CycleRefreshRate: return new detected MonitorIndex : {0}", (int)deviceNum);
return (int)deviceNum;
}
++deviceNum;
}
Log.Debug("CycleRefreshRate: return current default MonitorIndex, detection failed to find the new one : {0}",
GUIGraphicsContext.DX9Device.DeviceCaps.AdapterOrdinal);
return GUIGraphicsContext.DX9Device.DeviceCaps.AdapterOrdinal;
}
private void EnumDevices()
{
//populates Display Devices list
this.listDevices.Items.Clear();
DISPLAY_DEVICE d = new DISPLAY_DEVICE(0);
int devNum = 0;
bool result;
do
{
result = EnumDisplayDevices(IntPtr.Zero,
devNum, ref d, 0);
if (result)
{
string item = devNum.ToString() +
". " + d.DeviceString.Trim();
if ((d.StateFlags & 4) != 0) item += " - main";
this.listDevices.Items.Add(item);
}
devNum++;
} while (result);
}
public void GetScreens()
{
_screenCollection.Clear();
foreach (Screen screen in Screen.AllScreens)
{
const int dwf = 0;
var info = new DISPLAY_DEVICE();
string monitorname = null;
info.cb = Marshal.SizeOf(info);
if (EnumDisplayDevices(screen.DeviceName, 0, info, dwf))
{
monitorname = info.DeviceString;
}
if (monitorname == null)
{
monitorname = "";
}
foreach (AdapterInformation adapter in Manager.Adapters)
{
if (screen.DeviceName.StartsWith(adapter.Information.DeviceName.Trim()))
{
_screenCollection.Add(string.Format("{0} ({1}x{2}) on {3}",
monitorname, adapter.CurrentDisplayMode.Width, adapter.CurrentDisplayMode.Height,
adapter.Information.Description));
}
}
}
}
public static bool Rotate(uint DisplayNumber, Orientations Orientation)
{
if (DisplayNumber == 0)
{
throw new ArgumentOutOfRangeException("DisplayNumber", DisplayNumber, "First display is 1.");
}
bool result = false;
DISPLAY_DEVICE d = new DISPLAY_DEVICE();
DEVMODE dm = new DEVMODE();
d.cb = Marshal.SizeOf(d);
if (!NativeMethods.EnumDisplayDevices(null, DisplayNumber - 1, ref d, 0))
{
throw new ArgumentOutOfRangeException("DisplayNumber", DisplayNumber, "Number is greater than connected displays.");
}
if (0 != NativeMethods.EnumDisplaySettings(
d.DeviceName, NativeMethods.ENUM_CURRENT_SETTINGS, ref dm))
{
if ((dm.dmDisplayOrientation + (int)Orientation) % 2 == 1) // Need to swap height and width?
{
int temp = dm.dmPelsHeight;
dm.dmPelsHeight = dm.dmPelsWidth;
dm.dmPelsWidth = temp;
}
switch (Orientation)
{
case Orientations.DEGREES_CW_90:
dm.dmDisplayOrientation = NativeMethods.DMDO_270;
break;
case Orientations.DEGREES_CW_180:
dm.dmDisplayOrientation = NativeMethods.DMDO_180;
break;
case Orientations.DEGREES_CW_270:
dm.dmDisplayOrientation = NativeMethods.DMDO_90;
break;
case Orientations.DEGREES_CW_0:
dm.dmDisplayOrientation = NativeMethods.DMDO_DEFAULT;
break;
default:
break;
}
//Flip logic
//if (dm.dmDisplayOrientation == NativeMethods.DMDO_DEFAULT)
// dm.dmDisplayOrientation = NativeMethods.DMDO_90;
//else
// dm.dmDisplayOrientation = NativeMethods.DMDO_DEFAULT;
DISP_CHANGE ret = NativeMethods.ChangeDisplaySettingsEx(
d.DeviceName, ref dm, IntPtr.Zero,
DisplaySettingsFlags.CDS_UPDATEREGISTRY, IntPtr.Zero);
result = ret == 0;
}
return(result);
}
