/// <summary>
/// Returns the number of Displays using the Win32 functions.
/// </summary>
/// <returns>A collection of DisplayInfo with information about each monitor.</returns>
public static List<DisplayInfo> QueryDisplays()
{
// Output monitors.
var lMonitors = new List<DisplayInfo>();
// Get the monitors, for each one, add it to the list.
EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero,
delegate(IntPtr hMonitor, IntPtr hdcMonitor, ref Rect lprcMonitor, IntPtr dwData)
{
// Create a struct to contain the info and query it.
MonitorInfo mi = new MonitorInfo();
mi.Size = (uint)Marshal.SizeOf(mi);
mi.DeviceName = string.Empty;
bool bSuccess = GetMonitorInfo(hMonitor, ref mi);
// If it didn't fail, write the data.
if (bSuccess)
{
DisplayInfo di = new DisplayInfo();
di.ScreenWidth = mi.Monitor.Right - mi.Monitor.Left;
di.ScreenHeight = mi.Monitor.Bottom - mi.Monitor.Top;
di.MonitorArea = new Rect(mi.Monitor.Left, mi.Monitor.Top, di.ScreenWidth, di.ScreenHeight);
di.WorkArea = new Rect(mi.WorkArea.Left, mi.WorkArea.Top, (mi.WorkArea.Right - mi.WorkArea.Left), (mi.WorkArea.Bottom - mi.WorkArea.Top));
di.Availability = mi.Flags.ToString();
di.DeviceName = mi.DeviceName;
lMonitors.Add(di);
}
return true;
}, IntPtr.Zero);
return lMonitors;
}
public void ShouldDoNothingWhenComparisonCalculatorIsNull()
{
var monitorInfo = new MonitorInfo {MonitorConfig = new MonitorConfig()};
var settings = BuildSettings();
var compare = new RecordCompare(null, settings.Object);
compare.CalculateComparisons("Test", monitorInfo, null, null);
}
private static TestData PopulateTestData(bool populateAll)
{
//Define Defaults
var defineDefaults = new Mock<ISetupMonitorConfig>();
defineDefaults.Setup(x => x.CreateDefaultReduceLevels(It.IsAny<MonitorConfig>(), It.IsAny<List<ReduceLevel>>(), It.IsAny<IDbConnection>())).Verifiable();
//Cache
var monitorInfoDictionary = new ConcurrentDictionary<string, MonitorInfo>();
var monitorConfigsDictionary = new ConcurrentDictionary<string, MonitorConfig>();
var reductionLevel = new ReduceLevel { Resolution = 1000 };
var monitorConfig = new MonitorConfig { Name = "Test", ReduceLevels = new List<ReduceLevel> { reductionLevel } };
var monitorInfo = new MonitorInfo { TablesCreated = false, MonitorRecords = new List<MonitorRecord<double>> { new MonitorRecord<double>(DateTime.Now, 5) }, MonitorConfig = monitorConfig };
monitorInfoDictionary.TryAdd("Test", monitorInfo);
monitorConfigsDictionary.TryAdd("Test", monitorConfig);
reductionLevel = new ReduceLevel { Resolution = 1000 };
monitorConfig = new MonitorConfig { Name = "Jester", ReduceLevels = new List<ReduceLevel> { reductionLevel } };
monitorInfo = new MonitorInfo { TablesCreated = false, MonitorRecords = new List<MonitorRecord<double>> { new MonitorRecord<double>(DateTime.Now, 5) }, MonitorConfig = monitorConfig };
monitorInfoDictionary.TryAdd("Jester", monitorInfo);
monitorConfigsDictionary.TryAdd("Jester", monitorConfig);
var cache = new Mock<IDataCache>();
cache.SetupGet(x => x.MonitorInfo).Returns(monitorInfoDictionary);
cache.SetupGet(x => x.MonitorConfigs).Returns(monitorConfigsDictionary);
//Storage
var storage = new Mock<IStorageCommands>();
storage.Setup(x => x.Insert(It.IsAny<string>(), It.IsAny<IEnumerable<MonitorRecord<double>>>(), It.IsAny<IDbConnection>(), It.IsAny<IDbTransaction>())).Verifiable();
//Logic
var logic = new Mock<IRecordFlushUpdate>();
logic.Setup(x => x.UpdateExisting(It.IsAny<string>(), It.IsAny<SortedDictionary<long, MonitorRecord<double>>>(), It.IsAny<IDbConnection>(), It.IsAny<IDbTransaction>())).Verifiable();
//Db Provider
var transaction = new Mock<IDbTransaction>();
transaction.SetupGet(x => x.IsolationLevel).Returns(IsolationLevel.Serializable).Verifiable();
transaction.Setup(x => x.Rollback()).Verifiable();
transaction.Setup(x => x.Commit()).Verifiable();
var connection = new Mock<IDbConnection>();
connection.Setup(x => x.Open()).Verifiable();
connection.Setup(x => x.BeginTransaction()).Returns(transaction.Object).Verifiable();
connection.Setup(x => x.BeginTransaction(It.IsAny<IsolationLevel>())).Returns(transaction.Object).Verifiable();
var dbProviderFactory = new Mock<IStorageFactory>();
dbProviderFactory.Setup(x => x.CreateConnection()).Returns(connection.Object).Verifiable();
//Settings
var settings = BuildSettings();
return new TestData { Settings = settings, Cache = cache, DbProviderFactory = dbProviderFactory, Logic = logic, Storage = storage, Transaction = transaction, Connection = connection, DefineDefaults = defineDefaults };
}
public static bool setCurrentMonitor(MonitorInfo monitor)
{
bool success = false;
RegistryKey regKey = Registry.LocalMachine.CreateSubKey(registryPath); //Create if the key does not exist
if (regKey != null)
{
string[] valueNames = regKey.GetValueNames();
foreach (string valueName in valueNames)
{
if (valueName.ToLower().Contains(vmultiDevicePathSearch))
{
Console.WriteLine("Deleting registry key for " + valueName);
regKey.DeleteValue(valueName);
}
}
{
IEnumerable<HidDevice> hidDevices = HidDevices.Enumerate();
string devicePath = null;
foreach(HidDevice device in hidDevices)
{
if(device.DevicePath.ToLower().Contains(vmultiDevicePathSearch))
{
devicePath = device.DevicePath;
}
}
if(devicePath != null)
{
Console.WriteLine("Creating registry key for " + devicePath + ". Setting vmulti monitor to " + monitor.DevicePath);
regKey.SetValue("20-" + devicePath, monitor.DevicePath, RegistryValueKind.String);
Settings.Default.primaryMonitor = monitor.DevicePath;
success = true;
}
}
if(success)
{
//Disable and enable the vmulti device to force windows to update the touch monitor settings
Launcher.Launch("Driver", "devcon", " disable \"" + vmultiDevconSearch + "\"", new Action(delegate()
{
Launcher.Launch("Driver", "devcon", " enable \"" + vmultiDevconSearch + "\"", null);
}));
}
regKey.Close();
}
return success;
}
/// <summary>
/// Another way to use this is System.Windows.Forms.Screen.AllScreens;
/// </summary>
public IEnumerable<NativeRect> GetDisplayWorkAreas()
{
var screens = new List<NativeRect>();
EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero,
delegate(IntPtr hMonitor, IntPtr hdcMonitor, ref NativeRect lprcMonitor, IntPtr dwData)
{
var monitor = new MonitorInfo();
monitor.size = (uint)Marshal.SizeOf(monitor);
bool success = GetMonitorInfo(hMonitor, ref monitor);
if (success)
screens.Add(monitor.workArea);
return true;
}, IntPtr.Zero);
return screens;
}
public void ShouldRun()
{
var level = new ReduceLevel { Resolution = 1000 };
var connection = new Mock<IDbConnection>().Object;
var calculator = new Mock<IProcessingInstruction>();
calculator.Setup(x => x.CalculateExpectedValues("Test", level, It.IsAny<IDictionary<long, MonitorRecordComparison<double>>>(), connection)).Verifiable();
var monitorInfo = new MonitorInfo { MonitorConfig = new MonitorConfig { ComparisonCalculator = calculator.Object } };
var settings = BuildSettings();
var commands = new Mock<IStorageCommands>();
commands.Setup(x => x.Insert("TestSecondlyData", It.IsAny<IEnumerable<MonitorRecord<double>>>(), connection, null));
var compare = new RecordCompare(commands.Object, settings.Object);
compare.CalculateComparisons("Test", monitorInfo, level, connection);
calculator.VerifyAll();
}
public void AddSlaveMonitor (ProgressMonitor slaveMonitor, MonitorAction actionMask)
{
MonitorInfo smon = new MonitorInfo ();
smon.ActionMask = actionMask;
smon.Monitor = slaveMonitor;
monitors.Add (smon);
if ((actionMask & MonitorAction.SlaveCancel) != 0)
smon.CancellationTokenRegistration = slaveMonitor.CancellationToken.Register (OnSlaveCancelRequested);
}
private Rect CalculatorRoiPosition(Rect processPosition, Rect capturePosition, MonitorInfo monitorInfo)
{
if (capturePosition.Width > processPosition.Width && capturePosition.Height > processPosition.Height)
{
(Application.Current.MainWindow as MetroWindow).MessageShow("Error", DocumentHelper.Get(Message.FailedInvalidateRoiCapturePosition));
return(_dummyRect);
}
var correctCapturePosition = monitorInfo.Rect + capturePosition;
var distance = processPosition - correctCapturePosition;
return(capturePosition - distance);
}
public static string GetResolution(MonitorInfo monitor)
{
return($"{monitor.rcMonitor.Width} X {monitor.rcMonitor.Height}");
}
public static extern bool GetMonitorInfo(IntPtr monitorHandle, ref MonitorInfo monitorInfo);
internal static extern bool GetMonitorInfo(IntPtr hMonitor, MonitorInfo lpmi);
public static bool GetMonitorInfo(IntPtr hmon, out MonitorInfo info)
{
info = new MonitorInfo();
info.size = (uint)Marshal.SizeOf(info);
return InternalGetMonitorInfo(hmon, ref info);
}
public PrintPageBase(float pageWidth, float pageHeight, float scale, Control control, MonitorInfo monitorInfo)
{
Init(pageWidth, pageHeight, scale, control, monitorInfo);
}
public ImageViewModel(MonitorInfo monitor, ProgramSettings settings) : base(monitor, settings)
{
}
private void PrintMonitorInfo(string name, MonitorInfo info, ICommandInteraction writer, string lookup = null)
{
var ColorDefault = string.Format("\x1B[{0};{1}m", 0, 0);
var ColorRed = string.Format("\x1B[{0};{1}m", 1, 31);
var ColorGreen = string.Format("\x1B[{0};{1}m", 0, 32);
var ColorYellow = string.Format("\x1B[{0};{1}m", 0, 33);
if(info == null)
{
return;
}
if(info.Methods != null && info.Methods.Any(x => lookup == null || x.Name == lookup))
{
writer.WriteLine("\nFollowing methods are available:");
var methodsOutput = new StringBuilder();
foreach(var method in info.Methods.Where(x=> lookup == null || x.Name==lookup))
{
methodsOutput.Append(" - " + ColorGreen + TypePrettyName(method.ReturnType) + ColorDefault + " " + method.Name);
IEnumerable<ParameterInfo> parameters;
if(method.IsExtension())
{
parameters = method.GetParameters().Skip(1);
}
else
{
parameters = method.GetParameters();
}
parameters = parameters.Where(x => !Attribute.IsDefined(x, typeof(AutoParameterAttribute)));
methodsOutput.Append(" (");
var lastParameter = parameters.LastOrDefault();
foreach(var param in parameters.Where(x=> !x.IsRetval))
{
if(param.IsOut)
{
methodsOutput.Append(ColorYellow + "out ");
}
methodsOutput.Append(ColorGreen + TypePrettyName(param.ParameterType) + ColorDefault + " " + param.Name);
if(param.IsOptional)
{
methodsOutput.Append(" = " + ColorRed);
if(param.DefaultValue == null)
{
methodsOutput.Append("null");
}
else
{
if(param.ParameterType.Name == "String")
{
methodsOutput.Append('"');
}
methodsOutput.Append(param.DefaultValue);
if(param.ParameterType.Name == "String")
{
methodsOutput.Append('"');
}
}
methodsOutput.Append(ColorDefault);
}
if(lastParameter != param)
{
methodsOutput.Append(", ");
}
}
methodsOutput.Append(")");
writer.WriteLine(methodsOutput.ToString());
methodsOutput.Clear();
}
writer.WriteLine(string.Format("\n\rUsage:\n\r {0} MethodName param1 param2 ...\n\r", name));
}
if(info.Properties != null && info.Properties.Any(x => lookup == null || x.Name == lookup))
{
writer.WriteLine("\nFollowing properties are available:");
foreach(var property in info.Properties.Where(x=> lookup==null || x.Name==lookup))
{
writer.Write(string.Format(
" - " + ColorGreen + "{1} " + ColorDefault + "{0}\n\r",
property.Name,
TypePrettyName(property.PropertyType)
));
writer.Write(" available for ");
if(property.IsCurrentlyGettable(CurrentBindingFlags))
{
writer.Write(ColorYellow + "'get'" + ColorDefault);
}
if(property.IsCurrentlyGettable(CurrentBindingFlags) && property.IsCurrentlySettable(CurrentBindingFlags))
{
writer.Write(" and ");
}
if(property.IsCurrentlySettable(CurrentBindingFlags))
{
writer.Write(ColorYellow + "'set'" + ColorDefault);
}
writer.WriteLine();
}
writer.WriteLine(string.Format(
"\n\rUsage: \n\r - " + ColorYellow + "get" + ColorDefault + ": {0} PropertyName\n\r - " + ColorYellow + "set" + ColorDefault + ": {0} PropertyName Value\n\r",
name
));
}
if(info.Indexers != null && info.Indexers.Any(x => lookup == null || x.Name == lookup))
{
writer.WriteLine("\nFollowing indexers are available:");
foreach(var indexer in info.Indexers.Where(x=> lookup==null || x.Name==lookup))
{
var parameterFormat = new StringBuilder();
parameterFormat.Append(string.Format(
" - " + ColorGreen + "{1} " + ColorDefault + "{0}[",
indexer.Name,
TypePrettyName(indexer.PropertyType)
));
var parameters = indexer.GetIndexParameters();
var lastParameter = parameters.LastOrDefault();
foreach(var param in parameters)
{
parameterFormat.Append(ColorGreen + TypePrettyName(param.ParameterType) + ColorDefault + " " + param.Name);
if(param.IsOptional)
{
parameterFormat.Append(" = " + ColorRed);
if(param.DefaultValue == null)
{
parameterFormat.Append("null");
}
else
{
if(param.ParameterType.Name == "String")
{
parameterFormat.Append('"');
}
parameterFormat.Append(param.DefaultValue);
if(param.ParameterType.Name == "String")
{
parameterFormat.Append('"');
}
}
parameterFormat.Append(ColorDefault);
}
if(lastParameter != param)
{
parameterFormat.Append(", ");
}
}
parameterFormat.Append(']');
writer.Write(parameterFormat.ToString());
writer.Write(" available for ");
if(indexer.IsCurrentlyGettable(CurrentBindingFlags))
{
writer.Write(ColorYellow + "'get'" + ColorDefault);
}
if(indexer.IsCurrentlyGettable(CurrentBindingFlags) && indexer.IsCurrentlySettable(CurrentBindingFlags))
{
writer.Write(" and ");
}
if(indexer.IsCurrentlySettable(CurrentBindingFlags))
{
writer.Write(ColorYellow + "'set'" + ColorDefault);
}
writer.WriteLine();
}
writer.WriteLine(string.Format(
"\n\rUsage: \n\r - " + ColorYellow + "get" + ColorDefault + ": {0} IndexerName [param1 param2 ...]\n\r - "
+ ColorYellow + "set" + ColorDefault + ": {0} IndexerName [param1 param2 ... ] Value\n\r IndexerName is optional if every indexer has the same name.",
name
));
}
if(info.Fields != null && info.Fields.Any(x => lookup == null || x.Name == lookup))
{
writer.WriteLine("\nFollowing fields are available:");
foreach(var field in info.Fields.Where(x=> lookup==null || x.Name==lookup))
{
writer.Write(string.Format(" - " + ColorGreen + "{1} " + ColorDefault + "{0}", field.Name, TypePrettyName(field.FieldType)));
if(field.IsLiteral || field.IsInitOnly)
{
writer.Write(" (read only)");
}
writer.WriteLine("");
}
writer.WriteLine(string.Format(
"\n\rUsage: \n\r - " + ColorYellow + "get" + ColorDefault + ": {0} fieldName\n\r - " + ColorYellow + "set" + ColorDefault + ": {0} fieldName Value\n\r",
name
));
}
}
static bool MonitorEnum(IntPtr hMonitor, IntPtr hdcMonitor, ref Rect lprcMonitor, IntPtr dwData)
{
MonitorInfo mi = new MonitorInfo();
mi.size = (uint)Marshal.SizeOf(mi);
bool success = GetMonitorInfo(hMonitor, ref mi);
if (mi.flags == retSearchedDisplay.uintSearchedDisplay)
{
retSearchedDisplay.left = mi.monitor.left;
retSearchedDisplay.top = mi.monitor.top;
retSearchedDisplay.right = mi.monitor.right;
retSearchedDisplay.bottom = mi.monitor.bottom;
}
else if (retSearchedDisplay.top == retSearchedDisplay.bottom)
{
retSearchedDisplay.left = mi.monitor.left;
retSearchedDisplay.top = mi.monitor.top;
retSearchedDisplay.right = mi.monitor.right;
retSearchedDisplay.bottom = mi.monitor.bottom;
}
return true;
}
///<summary>
/// Checks the validity of the control values
///</summary>
///<returns></returns>
public bool CheckValues()
{
bool result = true;
errorProvider1.Clear();
if (string.IsNullOrEmpty(tbMinValue.Text))
{
errorProvider1.SetError(tbMinValue, "The minimum value must be a number between 0 and 99.");
result = false;
}
if (string.IsNullOrEmpty(tbSmooth.Text))
{
errorProvider1.SetError(tbSmooth, "The smooth value must be a number between 0 and 1.");
result = false;
}
try
{
MonitorInfo item = GetEditorItem();
ValidationResult validationResult = SettingsValidationHelper.Validate(item);
if (!validationResult.IsValid)
{
result = false;
foreach (KeyValuePair <string, ValidationErrorCollection> pair in validationResult)
{
switch (pair.Key)
{
case "MonitorInfo.AssemblyFileName":
{
errorProvider1.SetError(tbAssembly, pair.Value.ToString());
}
break;
case "MonitorInfo.TypeName":
{
errorProvider1.SetError(cboxMonitor, pair.Value.ToString());
}
break;
case "MonitorInfo.MinValue":
{
errorProvider1.SetError(tbMinValue, pair.Value.ToString());
}
break;
case "MonitorInfo.Key":
{
errorProvider1.SetError(tbKey, pair.Value.ToString());
}
break;
case "MonitorInfo.Smooth":
{
errorProvider1.SetError(tbSmooth, pair.Value.ToString());
}
break;
case "MonitorInfo.UpdateInterval":
{
errorProvider1.SetError(numUpdateInterval, pair.Value.ToString());
}
break;
case "MonitorInfo.Parameter":
{
errorProvider1.SetError(tbParameter, pair.Value.ToString());
}
break;
}
}
}
}
catch (Exception ex)
{
Logger.Debug("Exception caught and discarded: " + ex.Message +
" at MonitorInfoEditor.CheckValues");
errorProvider1.SetError(tbAssembly,
string.Format("General conversion error ({0}).", ex.Message));
result = false;
}
return(result);
}
private static extern bool GetMonitorInfo(IntPtr monitor, MonitorInfo info);
void Create()
{
ResetRemoveTimer();
// Create monitors
var n = uDesktopDuplication.Manager.monitors.Count;
for (int i = 0; i < n; ++i)
{
// Create monitor obeject
var go = Instantiate(monitorPrefab);
go.name = uDesktopDuplication.Manager.monitors[i].name;
// Saved infomation
if (savedInfoList.Count == i)
{
savedInfoList.Add(new SavedMonitorInfo());
Assert.AreEqual(i, savedInfoList.Count - 1);
}
var savedInfo = savedInfoList[i];
// Expand AABB
var mesh = go.GetComponent <MeshFilter>().mesh; // clone
var aabbScale = mesh.bounds.size;
aabbScale.y = Mathf.Max(aabbScale.y, aabbScale.x);
aabbScale.z = Mathf.Max(aabbScale.z, aabbScale.x);
mesh.bounds = new Bounds(mesh.bounds.center, aabbScale);
// Assign monitor
var texture = go.GetComponent <uDesktopDuplication.Texture>();
texture.monitorId = i;
var monitor = texture.monitor;
// Set width / height
float width = 1f, height = 1f;
switch (scaleMode)
{
case ScaleMode.Real:
width = monitor.widthMeter;
height = monitor.heightMeter;
break;
case ScaleMode.Fixed:
width = scale * (monitor.isHorizontal ? monitor.aspect : 1f);
height = scale * (monitor.isHorizontal ? 1f : 1f / monitor.aspect);
break;
case ScaleMode.Pixel:
width = scale * (monitor.isHorizontal ? 1f : monitor.aspect) * ((float)monitor.width / 1920);
height = scale * (monitor.isHorizontal ? 1f / monitor.aspect : 1f) * ((float)monitor.width / 1920);
break;
}
width *= savedInfo.widthScale;
height *= savedInfo.heightScale;
if (meshForwardDirection == MeshForwardDirection.Y)
{
go.transform.localScale = new Vector3(width, go.transform.localScale.y, height);
}
else
{
go.transform.localScale = new Vector3(width, height, go.transform.localScale.z);
}
// Set parent as this object
go.transform.SetParent(transform);
// Save
var info = new MonitorInfo();
info.gameObject = go;
info.originalRotation = go.transform.rotation;
info.originalLocalScale = go.transform.localScale;
info.uddTexture = texture;
info.mesh = mesh;
monitors.Add(info);
}
// Sort monitors in coordinate order
monitors.Sort((a, b) => a.uddTexture.monitor.left - b.uddTexture.monitor.left);
}
public void Init(float pageWidth, float pageHeight, float scale, Control control, MonitorInfo monitorInfo)
{
permmWidth = monitorInfo.permmWidth;
permmHeight = monitorInfo.permmHeight;
this.control = control;
orgPageWidth = pageWidth;
orgPageHeight = pageHeight;
this.pageHeight = orgPageHeight * scale;
this.pageWidth = orgPageWidth * scale;
this.scale = scale;
printMode = PrintDrawMode.SCREEN_MODE;
}
public static MonitorInfo GetMonitorInfo(IntPtr hMonitor)
{
var mi = new MonitorInfo();
if (!_GetMonitorInfo(hMonitor, mi))
{
throw new Win32Exception(Marshal.GetLastWin32Error());
}
return mi;
}
/// <summary>
/// 构造函数
/// </summary>
/// <param name="DataSheet">图表对应的数据工作表</param>
/// <param name="DrawingChart">Excel图形所在的Chart对象</param>
/// <param name="ParentApp">此图表所在的Excel类的实例对象</param>
/// <param name="DateSpan">此图表的TimeSpan跨度</param>
/// <param name="type">此图表的类型，则枚举DrawingType提供</param>
/// <param name="CanRoll">是图表是否可以滚动，即是动态图还是静态图</param>
/// <param name="date_ColNum">此测斜点的监测数据工作表中的每一天与其在工作表中对应的列号，
/// 以监测数据的日期key索引数据所在列号item</param>
/// <param name="usedRg">监测曲线的数据范围，此Range对象中，
/// 包括此工作表的UsedRange中的第一列，即深度的数据；但是不包括第一行的日期数据</param>
/// <param name="Info">记录数据信息的文本框</param>
/// <param name="FirstSeriesTag">第一条数据系列对应的Tag信息</param>
/// <param name="ProcessRegionData">在施工进度工作表中，每一个基坑区域相关的各种信息，比如区域名称，区域的描述，
/// 区域数据的Range对象，区域所属的基坑ID及其ID的数据等</param>
/// <remarks></remarks>
public ClsDrawing_Mnt_Incline(Excel.Worksheet DataSheet, Excel.Chart DrawingChart, Cls_ExcelForMonitorDrawing ParentApp,
DateSpan DateSpan, DrawingType type, bool CanRoll, TextFrame2 Info, MonitorInfo DrawingTag,
MntType MonitorType, Dictionary <DateTime, int> date_ColNum, Excel.Range usedRg,
SeriesTag_Incline FirstSeriesTag, clsData_ProcessRegionData ProcessRegionData = null)
: base(DataSheet, DrawingChart, ParentApp, type, CanRoll, Info, DrawingTag, MonitorType,
DateSpan, new clsDrawing_Mnt_RollingBase.SeriesTag(FirstSeriesTag.series, FirstSeriesTag.ConstructionDate))
{
//
// --------------------------------------------
try
{
ClsDrawing_Mnt_Incline with_1 = this;
with_1.P_rgMntData = usedRg; //'包括第一列，但是不包括第一行的日期。
Excel.Range colRange = usedRg.Columns[1] as Excel.Range;
with_1.F_YValues = ExcelFunction.ConvertRangeDataToVector <Single>(colRange);
with_1.Information = Info;
with_1._ExcavationDepth_lineAndTextbox = FirstSeriesTag;
with_1.F_dicDateAndColumnNumber = date_ColNum;
with_1.P_ProcessRegionData = ProcessRegionData;
with_1._inclineTopElevaion = Project_Expo.InclineTopElevaion;
// ----- 集合数据的记录
with_1.F_DicSeries_Tag[(int)LowIndexOfObjectsInExcel.SeriesInSeriesCollection] = FirstSeriesTag;
// -----对图例进行更新---------
//Call LegendRefresh(List_HasCurve)
}
catch (Exception ex)
{
MessageBox.Show("构造测斜曲线图出错。" + "\r\n" + ex.Message + "\r\n" +
ex.TargetSite.Name, "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
private void button4_Click(object sender, EventArgs e)
{
MonitorInfo mi = new MonitorInfo();
mi.size = (uint)Marshal.SizeOf(mi);
MessageBox(0, mi.size.ToString() + " inch", "Size", 0);
}
/// <summary>Populates the min/max info for the specified window handle</summary>
/// <param name="hwnd">The window handle</param>
/// <param name="lParam">Prameters</param>
private static void WindowGetMinMaxInfo(IntPtr hwnd, IntPtr lParam)
{
var mmi = (MinMaxInfo) Marshal.PtrToStructure(lParam, typeof (MinMaxInfo));
// Adjust the maximized size and position to fit the work area of the correct monitor
const int monitorDefaultToNearest = 0x00000002;
var monitor = MonitorFromWindow(hwnd, monitorDefaultToNearest);
if (monitor != IntPtr.Zero)
{
var monitorInfo = new MonitorInfo();
if (!GetMonitorInfo(monitor, monitorInfo)) return;
var rcWorkArea = monitorInfo.rcWork;
var rcMonitorArea = monitorInfo.rcMonitor;
mmi.ptMaxPosition.X = Math.Abs(rcWorkArea.left - rcMonitorArea.left);
mmi.ptMaxPosition.Y = Math.Abs(rcWorkArea.top - rcMonitorArea.top);
mmi.ptMaxSize.X = Math.Max(Math.Abs(rcWorkArea.right - rcWorkArea.left), 200);
mmi.ptMaxSize.Y = Math.Max(Math.Abs(rcWorkArea.bottom - rcWorkArea.top), 200);
}
Marshal.StructureToPtr(mmi, lParam, true);
}
public void Init()
{
ScriptedObject[] tmp = GameObject.Find ("_Characters").GetComponentsInChildren<ScriptedObject>();
Info = new List<MonitorInfo>();
foreach( ScriptedObject item in tmp )
{
MonitorInfo info = new MonitorInfo();
info.so = item;
info.go = item.gameObject;
info.name = info.go.name;
info.am = info.go.GetComponent<AnimationManager>();
info.nm = info.go.GetComponent<NavMeshAgentWrapper>();
info.tc = info.go.GetComponent<TaskCharacter>();
info.sm = this;
if ( info.name != "Player")
Info.Add(info);
}
}
internal ProcessWatcher CreateProcessWatcher(string procName, MonitorInfo info) => new ProcessWatcher(procName, info, this.Logger);
extern static int GetMonitorInfoA (IntPtr hmonitor, ref MonitorInfo info);
public static extern bool GetMonitorInfo(IntPtr hmon, [In, Out] MonitorInfo mi);
internal static extern bool GetMonitorInfo(IntPtr hMonitor, MonitorInfo lpmi);
public static Dictionary <string, object> ToObject(MonitorInfo mi) => new Dictionary <string, object>
{
["monitor"] = ToObject(mi.Monitor),
["work"] = ToObject(mi.WorkArea),
["flags"] = (int)mi.Flags,
};
internal async Task <bool> NavigateInternal <TResult>(IViewModel viewModel, Func <TResult, Task> callback1, Func <Task> callback2)
{
try
{
var viewModelType = viewModel.GetType();
Tuple <Window, bool> windowInfo = null;
// Check if the view model has a defined view
var viewAttrib = viewModelType.GetCustomAttribute <ViewAttribute>(false);
if (viewAttrib != null && viewAttrib.ViewType != null)
{
// Create the view - use the activator, since we dont expect any code in the view
windowInfo = await this.CreateDefaultWindow(callback1, callback2, Factory.Create(viewAttrib.ViewType) as FrameworkElement, viewModel);
}
else if (viewAttrib != null && !string.IsNullOrEmpty(viewAttrib.ViewName))
{
windowInfo = await this.CreateWindow(viewModel, callback1, callback2, viewAttrib.ViewName);
}
else // The viewmodel does not have a defined view... Maybe we have a data template instead
// If we dont have a dataTemplate... we try to find a matching FrameworkElement
{
windowInfo = await this.CreateWindow(viewModel, callback1, callback2, viewModelType.Name);
}
var window = windowInfo.Item1;
(viewModel as IDisposableObject).IsNotNull(x => x.Disposed += async(s, e) => await viewModel.Dispatcher.RunAsync(() => window.Close()));
window.Closing += Window_Closing;
window.Closed += (s, e) => (viewModel as ICloseAwareViewModel).IsNotNull(x => x.Close());
window.Activated += (s, e) =>
{
// This only applies to windows that are not maximized
if (window.WindowState != WindowState.Maximized)
{
// Check if the window is visible for the user If the user has for example
// undocked his laptop (which means he lost a monitor) and the application
// was running on the secondary monitor, we can't just start the window with
// that configuration
if (!MonitorInfo.WindowIsInAnyMonitor(window.GetWindowHandle()))
{
var source = PresentationSource.FromVisual(window);
var primaryBounds = MonitorInfo.PrimaryMonitorBounds;
window.Height = Math.Min(window.Height, primaryBounds.Height);
window.Width = Math.Min(window.Width, primaryBounds.Width);
window.Left = Math.Max(0, (primaryBounds.Width / source.CompositionTarget.TransformToDevice.M11 / 2) - (window.Width / 2));
window.Top = Math.Max(0, (primaryBounds.Height / source.CompositionTarget.TransformToDevice.M22 / 2) - (window.Height / 2));
}
else
{
// we have to make sure, that the title bar of the window is visible for
// the user
var monitorBounds = MonitorInfo.GetMonitorBounds(window.GetWindowHandle());
if (monitorBounds.HasValue)
{
window.Height = Math.Min(window.Height, monitorBounds.Value.Height);
window.Width = Math.Min(window.Width, monitorBounds.Value.Width);
window.Left = window.Left >= monitorBounds.Value.Left && window.Left <= monitorBounds.Value.Right ? window.Left : monitorBounds.Value.Left;
window.Top = window.Top >= monitorBounds.Value.Top && window.Top <= monitorBounds.Value.Bottom ? window.Top : monitorBounds.Value.Top;
}
else // set the left and top to 0
{
window.Left = 0;
window.Top = 0;
}
}
}
};
if (windowInfo.Item2)
{
window.ShowDialog();
}
else
{
window.Show();
}
return(true);
}
catch (XamlParseException)
{
throw;
}
catch (NullReferenceException)
{
throw;
}
catch (Exception e)
{
Debug.WriteLine(e);
return(false);
}
}
private static extern bool GetMonitorInfo(IntPtr hwnd, ref MonitorInfo mInfo);
static extern bool GetMonitorInfo(IntPtr hMonitor, ref MonitorInfo monitorInfo);
/// <summary>
/// 播放命令操作
/// </summary>
/// <param name="tvConfig"></param>
public void PlayOnTV(TvConfig tvConfig)
{
// 当布局变化时视频信息会变，清楚全部的 CameraPanelItem 信息
if (tvConfig.LayoutInfo != null)
{
this.cameras = new Dictionary <int, CameraPanelItem>();
}
// 处理数据对象，转换为封装的 Camera 等对象
CameraPanel cameraPanel = new CameraPanel {
LayoutInfo = tvConfig.LayoutInfo
};
if (tvConfig.MonitorInfo != null)
{
List <int> indexs = tvConfig.MonitorInfo.Select(t => t.Index).Distinct().ToList();
foreach (int index in indexs)
{
List <MonitorInfo> monitors = tvConfig.MonitorInfo.Where(t => t.Index == index).ToList();
CameraPanelItem panelItem = new CameraPanelItem {
Index = index
};
if (monitors.Count > 1)
{
CameraGroup cameraGroup = new CameraGroup
{
Interval = monitors[0].TimeInterval
};
foreach (var monitor in monitors)
{
DVR dvr = new DVR()
{
IP = monitor.Ip,
Port = monitor.AdminPort,
UserName = monitor.User,
Password = monitor.PassWord,
Id = monitor.Id
};
Camera camera = new Camera
{
StreamType = monitor.StreamType,
DVR = dvr,
Number = monitor.Channel
};
cameraGroup.Items.Add(camera);
}
panelItem.CameraGroup = cameraGroup;
panelItem.Flag = monitors[0].Flag;
panelItem.PlayType = PlayContentType.Group;
}
else
{
MonitorInfo monitor = monitors[0];
DVR dvr = new DVR()
{
IP = monitor.Ip,
Port = monitor.AdminPort,
UserName = monitor.User,
Password = monitor.PassWord,
Id = monitor.Id
};
Camera camera = new Camera()
{
DVR = dvr,
StreamType = monitor.StreamType,
Number = monitor.Channel
};
panelItem.Camera = camera;
panelItem.Flag = monitor.Flag;
panelItem.PlayType = PlayContentType.One;
if (monitor.Ip == null && monitor.User == null)
{
panelItem.Flag = 0;
}
}
cameraPanel.Cameras.Add(panelItem);
if (this.cameras.ContainsKey(index))
{
this.cameras.Remove(index);
}
this.cameras.Add(index, panelItem);
}
// 登录各个设备，为后面播放，
// 这里再返回赋值，因为每次都需要登录信息，否则失败
foreach (var item2 in cameraPanel.Cameras)
{
if (item2.Camera != null)
{
item2.Camera.DVR.Connection(false);
}
else if (item2.CameraGroup != null)
{
foreach (var item in item2.CameraGroup.Items)
{
item.DVR.Connection(false);
}
}
}
}
this.gridVideo.SetValue(GridHelpers.CamearPanelProperty, cameraPanel);
}
public SystemInformationViewModel(MonitorInfo monitor, ProgramSettings settings) : base(monitor, settings)
{
}
private static extern bool GetMonitorInfo(IntPtr hmon, ref MonitorInfo mi);
public bool TryRender(SpriteBuilder sb, BoxStyle style, MonitorContent content, MonitorInfo info)
{
Func <IContentRenderer> provider; if (TryGetValue(content.Type, out provider))
{
IContentRenderer renderer = provider();
if (renderer is IInfoContentRenderer)
{
InfoItem item; if (info.TryGetValue(content.Type, out item))
{
(renderer as IInfoContentRenderer).Render(sb, style, content, item); return(true);
}
}
else
{
renderer.Render(sb, style, content); return(true);
}
}
return(false);
}
public BaseViewModel(MonitorInfo monitor, ProgramSettings settings)
{
_monitor = monitor;
Settings = settings;
}
public GalleryViewModel(MonitorInfo monitor, ProgramSettings settings) : base(monitor, settings)
{
}
private static extern bool GetMonitorInfo(IntPtr monitorHandle, ref MonitorInfo info);
public static extern bool GetMonitorInfo(IntPtr hMonitor, [In, Out] MonitorInfo lpmi);
public static void CaptureScreen(MonitorInfo mi, string fileName)
{
CaptureScreen(mi).Save(fileName);
}
extern static int GetMonitorInfoA(IntPtr hmonitor, ref MonitorInfo info);
static extern bool GetMonitorInfo(IntPtr hmon, ref MonitorInfo mi);
private bool MonitorEnum(IntPtr hMonitor, IntPtr hdcMonitor, ref RectStruct lprcMonitor, IntPtr dwData)
{
MonitorInfo mi = new MonitorInfo();
mi.size = (uint)Marshal.SizeOf(mi);
GetMonitorInfo(hMonitor, ref mi);
bool isPrimary = (mi.flags == 1) ? true : false;
Rectangle bounds = new Rectangle(mi.monitor.left, mi.monitor.top,
mi.monitor.right - mi.monitor.left, mi.monitor.bottom - mi.monitor.top);
Screen screen = new Screen(m_screens.Count, bounds, isPrimary);
if (isPrimary) m_primary = m_screens.Count;
m_screens.Add(screen);
return true;
}
private static extern bool _GetMonitorInfo(IntPtr hMonitor, [In, Out] MonitorInfo lpmi);
public void AddFollowerMonitor (ProgressMonitor followerMonitor, MonitorAction actionMask)
{
MonitorInfo smon = new MonitorInfo ();
smon.ActionMask = actionMask;
smon.Monitor = followerMonitor;
monitors.Add (smon);
if ((actionMask & MonitorAction.FollowerCancel) != 0)
smon.CancellationTokenRegistration = followerMonitor.CancellationToken.Register (OnFollowerCancelRequested);
}
private void sendLoginReply(Server.Model.ClientInfoModel model, int dekstopRow, int desktopCol)
{
// get server's monitor info
List <Session.Data.SubData.MonitorInfo> monitorList = new List <MonitorInfo>();
int desktopLeft = 0;
int desktopTop = 0;
int desktopRight = 0;
int desktopBottom = 0;
foreach (WindowsHelper.MonitorInfo monitor in Utils.Windows.WindowsHelper.GetMonitorList())
{
if (desktopLeft > monitor.WorkArea.Left)
{
desktopLeft = monitor.MonitorArea.Left;
}
if (desktopTop > monitor.WorkArea.Top)
{
desktopTop = monitor.MonitorArea.Top;
}
if (desktopRight < monitor.WorkArea.Right)
{
desktopRight = monitor.MonitorArea.Right;
}
if (desktopBottom < monitor.WorkArea.Bottom)
{
desktopBottom = monitor.MonitorArea.Bottom;
}
monitorList.Add(new Session.Data.SubData.MonitorInfo()
{
LeftPos = monitor.MonitorArea.Left,
TopPos = monitor.MonitorArea.Top,
RightPos = monitor.MonitorArea.Right,
BottomPos = monitor.MonitorArea.Bottom
});
}
// send user data to client
UserSettingData settingData = Server.ServerDbHelper.GetInstance().GetUserSetting(model.DbUserId);
Session.Data.ServerUserSetting userSetting = new ServerUserSetting()
{
UserSetting = new UserSetting()
{
gridX = settingData.gridX,
gridY = settingData.gridY,
isSnap = settingData.isSnap,
}
};
// get user's application list
ServerApplicationStatus serverAppStatus = new ServerApplicationStatus();
serverAppStatus.UserApplicationList = new List <ApplicationEntry>();
foreach (ApplicationData appData in Server.ServerDbHelper.GetInstance().GetAppsWithUserId(model.DbUserId))
{
serverAppStatus.UserApplicationList.Add(new ApplicationEntry()
{
Identifier = appData.id,
Name = appData.name
});
}
// get user's preset list
ServerPresetsStatus serverPresetStatus = new ServerPresetsStatus();
serverPresetStatus.UserPresetList = new List <PresetsEntry>();
foreach (PresetData presetData in Server.ServerDbHelper.GetInstance().GetPresetByUserId(model.DbUserId))
{
List <ApplicationEntry> presetAppEntries = new List <ApplicationEntry>();
foreach (ApplicationData appData in presetData.AppDataList)
{
presetAppEntries.Add(new ApplicationEntry()
{
Identifier = appData.id,
Name = appData.name
});
}
List <VncEntry> presetVncEntries = new List <VncEntry>();
foreach (RemoteVncData vncData in presetData.VncDataList)
{
presetVncEntries.Add(new VncEntry()
{
Identifier = vncData.id,
DisplayName = vncData.name,
IpAddress = vncData.remoteIp,
Port = vncData.remotePort,
});
}
// get all vision inputs
List <InputAttributes> allInputList = Server.ServerVisionHelper.getInstance().GetAllVisionInputsAttributes();
List <InputAttributes> inputEntries = new List <InputAttributes>();
foreach (VisionData inputData in presetData.InputDataList)
{
inputEntries.Add(new InputAttributes()
{
InputId = inputData.id,
DisplayName = allInputList.First(inputAtt => inputAtt.InputId == inputData.id).DisplayName,
});
}
serverPresetStatus.UserPresetList.Add(new PresetsEntry()
{
Identifier = presetData.Id,
Name = presetData.Name,
ApplicationList = presetAppEntries,
VncList = presetVncEntries,
InputList = inputEntries,
});
}
// get user's priviledge
ServerMaintenanceStatus maintenanceStatus = new ServerMaintenanceStatus();
GroupData groupData = Server.ServerDbHelper.GetInstance().GetGroupByUserId(model.DbUserId);
maintenanceStatus.AllowMaintenance = groupData.allow_maintenance;
maintenanceStatus.AllowRemoteControl = groupData.allow_remote;
MonitorInfo allowViewingArea = new MonitorInfo();
if (groupData.share_full_desktop)
{
// same as full desktop
allowViewingArea.LeftPos = desktopLeft;
allowViewingArea.TopPos = desktopTop;
allowViewingArea.RightPos = desktopRight;
allowViewingArea.BottomPos = desktopBottom;
}
else
{
// get monitor info
MonitorData monitorData = Server.ServerDbHelper.GetInstance().GetMonitorByGroupId(groupData.id);
allowViewingArea.LeftPos = monitorData.Left;
allowViewingArea.TopPos = monitorData.Top;
allowViewingArea.RightPos = monitorData.Right;
allowViewingArea.BottomPos = monitorData.Bottom;
}
// prepare the VNC list
ServerVncStatus vncStatus = new ServerVncStatus();
List <VncEntry> vncEntries = new List <VncEntry>();
vncStatus.UserVncList = vncEntries;
foreach (RemoteVncData vncData in ServerDbHelper.GetInstance().GetRemoteVncList())
{
vncEntries.Add(new VncEntry()
{
Identifier = vncData.id,
DisplayName = vncData.name,
IpAddress = vncData.remoteIp,
Port = vncData.remotePort,
});
}
ServerLoginReply reply = new ServerLoginReply()
{
LoginName = model.Name,
UserId = model.DbUserId,
ServerLayout = new ServerScreenInfo()
{
MatrixCol = desktopCol,
MatrixRow = dekstopRow,
ServerMonitorsList = monitorList
},
// UserApplications
UserApplications = serverAppStatus,
// UserPresets
UserPresets = serverPresetStatus,
// UserMaintenance
UserMaintenance = maintenanceStatus,
// allowed viewing area
ViewingArea = allowViewingArea,
// Current vnc list
VncStatus = vncStatus,
// user settings
UserSetting = userSetting,
};
connectionMgr.SendData(
(int)CommandConst.MainCommandServer.UserPriviledge,
(int)CommandConst.SubCommandServer.DisplayInfo,
reply,
new List <string>()
{
model.SocketUserId
});
// send Input info to client
Session.Data.ServerInputStatus inputStatus = new Session.Data.ServerInputStatus()
{
InputAttributesList = Server.ServerVisionHelper.getInstance().GetAllVisionInputsAttributes(),
};
connectionMgr.SendData(
(int)CommandConst.MainCommandServer.Presents,
(int)CommandConst.SubCommandServer.VisionInput,
inputStatus,
new List <string>()
{
model.SocketUserId
});
}
private static extern bool InternalGetMonitorInfo(IntPtr hmon, ref MonitorInfo monitorInfo);
private static extern bool GetMonitorInfo(IntPtr monitorHandle, ref MonitorInfo info);
public void AddSlaveMonitor (IProgressMonitor slaveMonitor, MonitorAction actionMask)
{
MonitorInfo smon = new MonitorInfo ();
smon.ActionMask = actionMask;
smon.Monitor = slaveMonitor;
monitors.Add (smon);
if ((actionMask & MonitorAction.SlaveCancel) != 0)
slaveMonitor.CancelRequested += new MonitorHandler (OnSlaveCancelRequested);
}
/// <summary>
/// The HTML Help API's HtmlHelp method forces the help window to stretch across multiple monitors if it opens at a negative location (-x, -y).
/// This method resizes the window to the work-space size of the monitor that it is in.
/// This method must be called immediately after opening the Help window with the Help class.
/// </summary>
private bool AdjustHelpWindowSize()
{
IntPtr helpHandle = Process.GetCurrentProcess().MainWindowHandle; // get the Help window handle
if (helpHandle == null)
{
return false;
}
MonitorInfo monitorInfo = new MonitorInfo();
monitorInfo.cbSize = Marshal.SizeOf(monitorInfo);
if (!GetMonitorInfo(MonitorFromWindow(helpHandle, MONITOR_DEFAULTTONEAREST), ref monitorInfo))
{
return false;
}
Rect workSize = monitorInfo.rcWork;
return SetWindowPos(helpHandle, IntPtr.Zero, workSize.Left, workSize.Top, workSize.Right - workSize.Left, workSize.Bottom - workSize.Top, SWP_NOZORDER);
}
public MonitorInfo GetMonitorInfo(Type device)
{
var info = new MonitorInfo();
var methodsAndExtensions = new List<MethodInfo>();
var methods = GetAvailableMethods(device);
if(methods.Any())
{
methodsAndExtensions.AddRange(methods);
}
var properties = GetAvailableProperties(device);
if(properties.Any())
{
info.Properties = properties.OrderBy(x => x.Name);
}
var indexers = GetAvailableIndexers(device);
if(indexers.Any())
{
info.Indexers = indexers.OrderBy(x => x.Name);
}
var fields = GetAvailableFields(device);
if(fields.Any())
{
info.Fields = fields.OrderBy(x => x.Name);
}
var extensions = TypeManager.Instance.GetExtensionMethods(device).Where(x => x.IsExtensionCallable()).OrderBy(x=>x.Name);
if(extensions.Any())
{
methodsAndExtensions.AddRange(extensions);
}
if(methodsAndExtensions.Any())
{
info.Methods = methodsAndExtensions.OrderBy(x => x.Name);
}
return info;
}
public static extern bool GetMonitorInfo(IntPtr hMonitor, ref MonitorInfo lpmi);
public override Xwt.Rectangle GetUsableMonitorGeometry (int screenNumber, int monitor_id)
{
var screen = Gdk.Display.Default.GetScreen (screenNumber);
Gdk.Rectangle geometry = screen.GetMonitorGeometry (monitor_id);
List<MonitorInfo> screens = new List<MonitorInfo> ();
EnumDisplayMonitors (IntPtr.Zero, IntPtr.Zero, delegate (IntPtr hmonitor, IntPtr hdc, IntPtr prect, IntPtr user_data) {
var info = new MonitorInfo ();
info.Size = Marshal.SizeOf (info);
GetMonitorInfoA (hmonitor, ref info);
// In order to keep the order the same as Gtk, we need to put the primary monitor at the beginning.
if ((info.Flags & MonitorInfoFlagsPrimary) != 0)
screens.Insert (0, info);
else
screens.Add (info);
return 1;
}, IntPtr.Zero);
MonitorInfo monitor = screens[monitor_id];
Rect visible = monitor.VisibleFrame;
Rect frame = monitor.Frame;
// Rebase the VisibleFrame off of Gtk's idea of this monitor's geometry (since they use different coordinate systems)
int x = geometry.X + (visible.Left - frame.Left);
int width = visible.Width;
int y = geometry.Y + (visible.Top - frame.Top);
int height = visible.Height;
return new Xwt.Rectangle (x, y, width, height);
}
public static extern bool al_get_monitor_info(int adapter, MonitorInfo *info);
