private static bool WaitRaw(object @lock, int timeOut, bool domain) { if (@lock == null) { throw new ArgumentNullException(); } if (timeOut < 0 && timeOut != Timeout.Infinite) { throw new ArgumentOutOfRangeException(); } return(Helper.SimpleWrap <bool>( delegate(ClrSyncManager manager) { if (timeOut == Timeout.Infinite) { return MonitorHelper.WaitDelegate(manager, @lock, "Monitor.Wait"); } else { return MonitorHelper.WaitDelegateWithTimeout(manager, @lock, "Monitor.Wait"); } }, delegate() { return Original::Monitor.Wait(@lock, timeOut, domain); })); }
private ChartDTO GetChartDataByHead(MonitorCollectDataEntity eHead) { MonitorHelper oldHelper = new MonitorHelper(); IList <MonitorCollectDataEntryEntity> lstDetail = oldHelper.GetMonitorData(eHead.FID, mIsCompressed); mDetailEntity = lstDetail; if (Convert.ToInt32(Sensor.SensorType).Equals(Convert.ToInt32(Common.Consts.SensorType.Sterilizer))) { // 灭菌 return(GetSterilizerChartData(eHead, lstDetail)); } else if (Convert.ToInt32(Sensor.SensorType).Equals(Convert.ToInt32(Common.Consts.SensorType.Washer))) { // 清洗 return(GetWasherChartData(eHead, lstDetail)); } else { logger.WarnFormat("未处理的设备类型([传感器:{0},设备类型:{1}])", Sensor.SensorKey, Sensor.SensorType); return(null); } //return null; }
// Instantiate and layout game views based on the setting. void LayoutViews() { CloseAllViews(); var views = MonitorHelper.GetDisplays(); int viewCount = 0; if (views == null || views.Count < 1) { viewCount = 7; } else { viewCount = views.Count; } for (var i = 0; i < viewCount; i++) { if (_table.viewTable[i] == -1) { continue; // "None", display no screen } var view = (EditorWindow)ScriptableObject.CreateInstance(GameViewType); view.Show(); ChangeTargetDisplay(view, _table.viewTable[i]); SendViewToScreen(view, i); } }
private void ReadFile() { MonitorTimer.Stop(); if (!File.Exists(_watchFile)) { return; } Dispatcher.Invoke(() => { var fileText = MonitorHelper.ReadFile(_watchFile); if (fileText.Length > _lastFileSize) { _lastFileSize = fileText.Length; MonitorRtf.Text = fileText; Title = "Monitor - Updated " + DateTime.Now.ToLongTimeString(); if (AutoScrollToBottom) { ScrollDown(); } } }); MonitorTimer.Start(); }
private void Position(Point openPoint) { openPoint.Y -= Height + 15; // Ensure that this window is entirely within the screen. Rect openLocation = new Rect(openPoint, new Size(Width, Height)); Rect monitor = MonitorHelper.MonitorWorkingAreaFromRect(openLocation); if (openLocation.Left < monitor.Left) { openLocation.Offset(monitor.Left - openLocation.Left, 0); } if (openLocation.Top < monitor.Top) { openLocation.Offset(0, monitor.Top - openLocation.Top); } if (openLocation.Right > monitor.Right) { openLocation.Offset(monitor.Right - openLocation.Right, 0); } if (openLocation.Bottom > monitor.Bottom) { openLocation.Offset(0, monitor.Bottom - openLocation.Bottom); } Left = openLocation.Left; Top = openLocation.Top; }
// The calling thread must own the lock on the obj parameter. If the calling thread owns the lock on // the specified object, and has made an equal number of Exit and Enter calls for the object, then the // lock is released. If the calling thread has not invoked Exit as many times as Enter, the lock is not released. // If the lock is released and other threads are in the ready queue for the object, // one of the threads acquires the lock. If other threads are in the waiting queue waiting // to acquire the lock, they are not automatically moved to the ready queue when the owner of // the lock calls Exit. To move one or more waiting threads into the ready queue, call Pulse or // PulseAll before invoking Exit. #endregion public static void Exit(object @lock) { if (@lock == null) { throw new ArgumentNullException(); } Helper.SimpleWrap <bool>( delegate(ClrSyncManager manager) { manager.SetMethodInfo("Monitor.Exit"); manager.SyncVarAccess(@lock, MSyncVarOp.LOCK_RELEASE); try { Original::Monitor.Exit(@lock); } catch (Exception e) { manager.CommitSyncVarAccess(); throw e; } MonitorHelper.DecrementReentrancyCount(@lock); manager.CommitSyncVarAccess(); return(false); }, delegate() { Original::Monitor.Exit(@lock); return(false); }); }
public String insertaSueno(int id_evento, String comentarios, DateTime inicio, DateTime fin) { /** * Este servicio inserta un evento de Sueño cuando se tenga un status de sueño, descanso e inactivo. * **/ String response = ""; int codigoOperacion = -1; if (fin == Convert.ToDateTime("0001-01-01 00:00:00")) { /** * Indica que la fecha_fin es null. * **/ codigoOperacion = MonitorHelper.insertarSueno(id_evento, comentarios, inicio, fin); } else { var diferencia = MonitorHelper.diferencia(inicio, fin); if (diferencia > 480.00) { codigoOperacion = 1; } else if (diferencia < 0.0) { codigoOperacion = 2; } else if (diferencia >= 0.0 && diferencia <= 15.00) { codigoOperacion = 3; } else { codigoOperacion = MonitorHelper.insertarSueno(id_evento, comentarios, inicio, fin); } } switch (codigoOperacion) { case 0: response = "Sueño Insertado con éxito"; break; case 1: response = "ERROR: La diferencia entre la fecha de inicio y fecha fin es mayor a 8 hrs"; break; case 2: response = "ERROR: La fecha inicio del sueño debe ser mayor a la fecha fin del sueño"; break; case 3: response = "ERROR: La duración del sueño debe ser mayor a 15 minutos"; break; default: response = "ERROR al insertar Sueño"; break; } return(response); }
private void DetectScreens() { var monitors = MonitorHelper.AllMonitorsGranular(); _minLeft = monitors.Min(m => m.NativeBounds.Left); _minTop = monitors.Min(m => m.NativeBounds.Top); _maxRight = monitors.Max(m => m.NativeBounds.Right); _maxBottom = monitors.Max(m => m.NativeBounds.Bottom); MainCanvas.Children.Clear(); foreach (var monitor in monitors) { var rect = new Rectangle { Width = monitor.NativeBounds.Width, Height = monitor.NativeBounds.Height, StrokeThickness = 6 }; rect.SetResourceReference(Shape.StrokeProperty, "Element.Foreground"); rect.SetResourceReference(Shape.FillProperty, monitor.AdapterName == Monitor.AdapterName ? "Element.Background.Checked" : "Element.Background.Hover"); var textBlock = new TextBlock { Text = monitor.AdapterName, TextAlignment = TextAlignment.Center, HorizontalAlignment = HorizontalAlignment.Center, VerticalAlignment = VerticalAlignment.Center, FontSize = 26, TextWrapping = TextWrapping.Wrap, Margin = new Thickness(15) }; textBlock.SetResourceReference(TextBlock.ForegroundProperty, "Element.Foreground"); var viewbox = new Viewbox { Child = textBlock, Width = monitor.NativeBounds.Width, Height = monitor.NativeBounds.Height, }; MainCanvas.Children.Add(rect); MainCanvas.Children.Add(viewbox); Canvas.SetLeft(rect, monitor.NativeBounds.Left); Canvas.SetTop(rect, monitor.NativeBounds.Top); Canvas.SetLeft(viewbox, monitor.NativeBounds.Left); Canvas.SetTop(viewbox, monitor.NativeBounds.Top); Panel.SetZIndex(rect, 1); Panel.SetZIndex(viewbox, 2); } MainCanvas.Width = Math.Abs(_minLeft) + Math.Abs(_maxRight); MainCanvas.Height = Math.Abs(_minTop) + Math.Abs(_maxBottom); MainCanvas.Measure(new Size(MainCanvas.Width, MainCanvas.Height)); MainCanvas.Arrange(new Rect(MainCanvas.DesiredSize)); SetViewPort(_minLeft, _maxRight, _minTop, _maxBottom); }
private async Task SendMessage(MonitorMessage message) { if (message.MessageType == MonitorMessageTypes.HttpRequest || message.MessageType == MonitorMessageTypes.ServiceBusReceiver) { var uri = MonitorHelper.GetUri(message.RequestAddress); var telemetryItem = new RequestTelemetry(); telemetryItem.Context.Operation.Id = message.Id; telemetryItem.Context.Operation.ParentId = message.CorrelationId; telemetryItem.Name = $"{message.RequestMethod}-{uri.Authority}"; telemetryItem.Timestamp = message.StartTime; telemetryItem.Duration = message.Duration; telemetryItem.Success = !message.IsError; telemetryItem.ResponseCode = message.ResponseCode; telemetryItem.Url = uri; telemetryItem.Source = message.ProcessName; SetTelemetryProperties(telemetryItem.Properties, message); _client.TrackRequest(telemetryItem); } else if (message.MessageType == MonitorMessageTypes.HttpClient || message.MessageType == MonitorMessageTypes.ServiceBusSender || message.MessageType == MonitorMessageTypes.GenericObjectSender) { var uri = MonitorHelper.GetUri(message.RequestAddress); var telemetryItem = new DependencyTelemetry(); telemetryItem.Context.Operation.Id = message.Id; telemetryItem.Context.Operation.ParentId = message.CorrelationId; telemetryItem.Name = $"{message.RequestMethod}-{uri.Authority}"; telemetryItem.Timestamp = message.StartTime; telemetryItem.Duration = message.Duration; telemetryItem.Success = !message.IsError; telemetryItem.ResultCode = message.ResponseCode; telemetryItem.Data = message.RequestAddress; telemetryItem.Type = message.CallType; telemetryItem.Target = uri.Authority; SetTelemetryProperties(telemetryItem.Properties, message); _client.TrackDependency(telemetryItem); } else { var telemetryItem = new TraceTelemetry(); telemetryItem.Context.Operation.Id = message.Id; telemetryItem.Context.Operation.ParentId = message.CorrelationId; telemetryItem.Message = $"{message.MessageType}-{message.RequestMethod}-{message.ProcessName}"; telemetryItem.Timestamp = message.StartTime; telemetryItem.SeverityLevel = message.IsError ? SeverityLevel.Error : SeverityLevel.Information; SetTelemetryProperties(telemetryItem.Properties, message); _client.TrackTrace(telemetryItem); } }
/// <summary> /// 初始加载,监测组和监测地点 /// </summary> private void LoadedSearchCondition() { //绑定监测组 _groupCbox.ItemsSource = MonitorHelper.GetDistinctGroupByPlan(sealedorginfo); //绑定监测地点 //string activityId = CO_IA.Client.RiasPortal.ModuleContainer.Activity.Guid; ActivityPlaceInfo[] getActivityPlace = PrototypeDatas.GetPlacesByActivityId(activityId); _workAddressCbox.ItemsSource = getActivityPlace.ToList(); }
static void Main(string[] args) { var _monitorInfos = new List <MonitorInfoWithHandle>(); GetMonitors(); /// <summary> /// Monitor Enum Delegate /// </summary> /// <param name="hMonitor">A handle to the display monitor.</param> /// <param name="hdcMonitor">A handle to a device context.</param> /// <param name="lprcMonitor">A pointer to a RECT structure.</param> /// <param name="dwData">Application-defined data that EnumDisplayMonitors passes directly to the enumeration function.</param> /// <returns></returns> bool MonitorEnum(IntPtr hMonitor, IntPtr hdcMonitor, ref RECT lprcMonitor, IntPtr dwData) { var mi = new MONITORINFO(); mi.size = (uint)Marshal.SizeOf(mi); MonitorHelper.GetMonitorInfo(hMonitor, ref mi); // Add to monitor info _monitorInfos.Add(new MonitorInfoWithHandle(hMonitor, mi)); return(true); } /// <summary> /// Gets the monitors. /// </summary> /// <returns></returns> MonitorInfoWithHandle[] GetMonitors() { // New List _monitorInfos = new List <MonitorInfoWithHandle>(); // Enumerate monitors MonitorHelper.EnumDisplayMonitors(IntPtr.Zero, IntPtr.Zero, MonitorEnum, IntPtr.Zero); // Return list return(_monitorInfos.ToArray()); } DEVICE_SCALE_FACTOR scaleValue1; DEVICE_SCALE_FACTOR scaleValue2; var monitor1 = _monitorInfos[0].MonitorHandle; GetScaleFactorForMonitor(monitor1, out scaleValue1); var monitor2 = _monitorInfos[1].MonitorHandle; GetScaleFactorForMonitor(monitor2, out scaleValue2); Console.ReadKey(); }
private void Button_Click_8(object sender, RoutedEventArgs e) { if (string.IsNullOrEmpty(MonitorHelper.GetRpt(Settings.Default.ProfilePath))) { MessageBox.Show("No Rpt File present", "ASM", MessageBoxButton.OK, MessageBoxImage.Information); } else { var path = Path.Combine(Settings.Default.ProfilePath, MonitorHelper.GetRpt(Settings.Default.ProfilePath)); File.Delete(path); } }
private void captionImg_PreviewMouseLeftButtonDown(object sender, MouseButtonEventArgs e) { if (WindowState == WindowState.Maximized) { Rect rect = MonitorHelper.MonitorWorkingAreaFromWindow(this); SystemCommands.ShowSystemMenu(this, new Point(rect.Left, rect.Top + 27)); } else { SystemCommands.ShowSystemMenu(this, new Point(Left, 29 + Top)); } }
public static void InitLanguageInfos(string strModuleID) { try { if (Session == null || Session.LangTypeInfo == null) { return; } ListLanguageInfos.Clear(); VoiceCyber.UMP.Communications.WebRequest webRequest = new VoiceCyber.UMP.Communications.WebRequest(); webRequest.Code = (int)RequestCode.WSGetLangList; webRequest.Session = Session; webRequest.ListData.Add(Session.LangTypeInfo.LangID.ToString()); webRequest.ListData.Add(string.Empty); webRequest.ListData.Add(string.Format("0{0}61", ConstValue.SPLITER_CHAR)); webRequest.ListData.Add(string.Format("0{0}{1}", ConstValue.SPLITER_CHAR, strModuleID)); webRequest.ListData.Add(string.Empty); webRequest.ListData.Add(string.Empty); MonitorHelper.AddWebRequest(webRequest); Service11012Client client = new Service11012Client( WebHelper.CreateBasicHttpBinding(Session) , WebHelper.CreateEndpointAddress(Session.AppServerInfo, "Service11012")); WebReturn webReturn = client.DoOperation(webRequest); MonitorHelper.AddWebReturn(webReturn); client.Close(); if (!webReturn.Result) { ShowExceptionMessage(string.Format("{0}\t{1}", webReturn.Code, webReturn.Message)); } for (int i = 0; i < webReturn.ListData.Count; i++) { OperationReturn optReturn = XMLHelper.DeserializeObject <LanguageInfo>(webReturn.ListData[i]); if (!optReturn.Result) { ShowExceptionMessage(string.Format("{0}\t{1}", optReturn.Code, optReturn.Message)); return; } LanguageInfo langInfo = optReturn.Data as LanguageInfo; if (langInfo == null) { ShowExceptionMessage(string.Format("LanguageInfo is null")); return; } ListLanguageInfos.Add(langInfo); } WriteLog("AppLang", string.Format("Init LanguageInfos end,ListLanguageInfos.count =" + ListLanguageInfos.Count)); } catch (Exception ex) { WriteLog("InitLang", string.Format("InitLang fail.\t{0}", ex.Message)); } }
private void indicator_PreviewMouseUp(object sender, MouseButtonEventArgs e) { _isDown = false; if (_isDragging) { _isDragging = false; indicator.ReleaseMouseCapture(); // // Snap to an invisible grid. // double left = Round(Left, 50); double top = Round(Top, 50); // // Make sure we're still fully on the monitor. // Rect monitor = MonitorHelper.MonitorWorkingAreaFromRect(new Rect(left, top, ActualWidth, ActualHeight)); if (left < monitor.Left + 10) { left = monitor.Left + 10; } else if (left > monitor.Right - ActualWidth - 10) { left = monitor.Right - ActualWidth - 10; } if (top < monitor.Top + 10) { top = monitor.Top + 10; } else if (top > monitor.Bottom - ActualHeight - 10) { top = monitor.Bottom - ActualHeight - 10; } DoubleAnimation topAnim = new DoubleAnimation(top, new Duration(TimeSpan.FromMilliseconds(300)), FillBehavior.Stop); topAnim.EasingFunction = new QuarticEase(); topAnim.Completed += (obj, args) => { Top = top; }; DoubleAnimation leftAnim = new DoubleAnimation(left, new Duration(TimeSpan.FromMilliseconds(300)), FillBehavior.Stop); leftAnim.EasingFunction = new QuarticEase(); leftAnim.Completed += (obj, args) => { Left = left; }; BeginAnimation(TopProperty, topAnim); BeginAnimation(LeftProperty, leftAnim); } }
public void Reset() { #if MONITOR MonitorHelper.Reset("monitor.bin"); foreach (var s in Enum.GetValues(typeof(Stage))) { MonitorHelper.Reset($"{Stage}.bin"); } #endif Console.WriteLine($"[!] [VS{battle?.Opponent.Name}] Reset detected"); Stage = Stage.Synchronization; skipPacketCount = 0; battle = Mode == Mode.Ai ? new AIBattle() : new Battle(); }
// Monitor.TryEnter (Object) Attempts to acquire an exclusive lock on the specified object. public static bool TryEnterRaw(object @lock, int timeOut, MSyncVarOp operation, string name) { if (@lock == null) { throw new ArgumentNullException(); } if (timeOut < 0 && timeOut != Timeout.Infinite) { throw new ArgumentOutOfRangeException(); } return(Helper.SimpleWrap <bool>( delegate(ClrSyncManager manager) { bool flag; while (true) { try { manager.SetMethodInfo(name); manager.SyncVarAccess(@lock, operation); flag = Original::Monitor.TryEnter(@lock); if (!flag && timeOut == Timeout.Infinite) { manager.LocalBacktrack(); continue; } } catch (Exception e) { manager.CommitSyncVarAccess(); throw e; } if (flag) { MonitorHelper.IncrementReentrancyCount(@lock); } if (!flag) { manager.MarkTimeout(); } manager.CommitSyncVarAccess(); break; } return flag; }, delegate() { return Original::Monitor.TryEnter(@lock, timeOut); })); }
private readonly Rectangle _capturedBounds; //Simple rectangle that start at 0,0 and has width and height set to the rectangle size public ScreenMirror(Device device, Orchestrator orchestrator, INanoleafClient nanoleafClient, ScaleType scaleType) { _nanoleafClient = nanoleafClient; _externalControlEndpoint = _nanoleafClient.ExternalControlEndpoint; _screenBounds = MonitorHelper.GetScreenBounds(device.ScreenMirrorMonitorIndex); _panels = orchestrator.PanelLayout.GetScaledTriangles(_screenBounds.Width, _screenBounds.Height, scaleType); //Set the rectangle size to 1/3th of the length of a side of the triangle. TODO: test what size is best var triangle = _panels.FirstOrDefault().Polygon; _rectangleSize = (int)Math.Floor(System.Windows.Point.Subtract(triangle.Points[0], triangle.Points[1]).Length / 3); _capturedBounds = new Rectangle(0, 0, _rectangleSize, _rectangleSize); }
// Send a game view to a given screen. static void SendViewToScreen(EditorWindow view, int screenIndex) { const int kMenuHeight = 22; var firstDisplayInfo = MonitorHelper.GetDisplay(0); var displayInfo = MonitorHelper.GetDisplay(screenIndex); var monitorArea = displayInfo.MonitorArea; float relativeScaleFactor = displayInfo.scaleFactor / firstDisplayInfo.scaleFactor; // we need to get the scaled rect based on the main screen scale factor and the target screen scale factor. var origin = new Vector2(monitorArea.left, monitorArea.top - kMenuHeight); var size = new Vector2((monitorArea.right - monitorArea.left) * relativeScaleFactor, (monitorArea.bottom - monitorArea.top + kMenuHeight) * relativeScaleFactor); if (relativeScaleFactor < 1) { // if the main screen has a higher scale than the others, // origin changes as well. origin.x *= relativeScaleFactor; origin.y = monitorArea.top * relativeScaleFactor - kMenuHeight; } //round to int values, otherwise the window position gets reset origin.x = Mathf.FloorToInt(origin.x); origin.y = Mathf.FloorToInt(origin.y); size.x = Mathf.FloorToInt(size.x); size.y = Mathf.FloorToInt(size.y); // not sure why multiple sets are necessary, but otherwise the menu height offset does not work correctly. var posRect = new Rect(origin, size); view.position = posRect; view.minSize = view.maxSize = size; view.position = posRect; view.minSize = view.maxSize = size; view.position = posRect; view.minSize = view.maxSize = size; view.position = posRect; view.minSize = view.maxSize = size; view.position = posRect; view.minSize = view.maxSize = size; view.position = posRect; view.minSize = view.maxSize = size; view.position = posRect; EditorUtility.SetDirty(view); }
public String insertaSuenoEnActivo(int id_evento_arriba, int id_evento_abajo, String comentarios, DateTime inicio, DateTime fin, bool esPrimero) { int codigoOperacion = -1; String response = ""; var diferencia = MonitorHelper.diferencia(inicio, fin); if (diferencia > 480.00) { codigoOperacion = 1; } else if (diferencia < 0.0) { codigoOperacion = 2; } else if (diferencia >= 0.0 && diferencia <= 15.00) { codigoOperacion = 3; } else { codigoOperacion = MonitorHelper.insertaSuenoEnActivo(id_evento_arriba, id_evento_abajo, comentarios, inicio, fin, esPrimero); } switch (codigoOperacion) { case 0: response = "Sueño Insertado con éxito en evento activo"; break; case 1: response = "ERROR: La diferencia entre la fecha de inicio y fecha fin es mayor a 8 hrs"; break; case 2: response = "ERROR: La fecha inicio del sueño debe ser mayor a la fecha fin del sueño"; break; case 3: response = "ERROR: La duración del sueño debe ser mayor a 15 minutos"; break; default: response = "ERROR al insertar Sueño"; break; } return(response); }
private void CenterOnScreen() { //Since the list of monitors could have been changed, it needs to be queried again. var monitors = MonitorHelper.AllMonitorsGranular(); //Detect closest screen to the point (previously selected top/left point or current mouse coordinate). var point = new Point((int)Left, (int)Top); var closest = monitors.FirstOrDefault(x => x.Bounds.Contains(point)) ?? monitors.FirstOrDefault(x => x.IsPrimary) ?? monitors.FirstOrDefault(); if (closest == null) { throw new Exception("It was not possible to get a list of known screens."); } //Move the window to the correct location. Left = closest.WorkingArea.Left + closest.WorkingArea.Width / 2d - ActualWidth / 2d; Top = closest.WorkingArea.Top + closest.WorkingArea.Height / 2d - ActualHeight / 2d; }
public static IGlobalConfiguration UseJobMonitor( this IGlobalConfiguration configuration, JobKitOptions options, params Assembly[] assemblies) { var map = MonitorHelper.GetMap(assemblies); if (map != null) { DashboardRoutes.Routes.AddRazorPage(JobKitRoute.Monitor.Url, x => new MonitorPage(ValidateRangeType.Daily, map, options)); DashboardRoutes.Routes.AddRazorPage(JobKitRoute.Monitor.CategoryUrl, x => new MonitorPage(x.Groups["categoryId"].Value, map, options)); NavigationMenu.Items.Add(page => new MenuItem(Strings.MonitorPage_Title, page.Url.To(JobKitRoute.Monitor.Url)) { Active = page.RequestPath.StartsWith(JobKitRoute.Monitor.Url), Metric = new DashboardMetric("monitor-count", x => new Metric(map.JobCollection.Values.Sum(y => y.Count))) }); } return(configuration); }
private void SetTelemetryProperties(IDictionary <string, string> properties, MonitorMessage message) { const int LIMIT = 8192; properties["CorrelationId"] = message.CorrelationId; properties["RequestHeaders"] = MonitorHelper.LimitString(JsonConvert.SerializeObject(message.RequestHeaders, Formatting.Indented), LIMIT); properties["ResponseHeaders"] = MonitorHelper.LimitString(JsonConvert.SerializeObject(message.ResponseHeaders, Formatting.Indented), LIMIT); properties["RequestArchitectureMetadata"] = $"{message.RequestArchitectureMetadata}"; properties["ResponseArchitectureMetadata"] = $"{message.ResponseArchitectureMetadata}"; properties["ProcessName"] = message.ProcessName; properties["RequestBody"] = MonitorHelper.LimitString(message.RequestBody, LIMIT); properties["RequestUser"] = MonitorHelper.LimitString(message.RequestUser, LIMIT); properties["ResponseBody"] = MonitorHelper.LimitString(message.ResponseBody, LIMIT); if (!String.IsNullOrEmpty(message.ErrorMessage)) { properties["ErrorMessage"] = MonitorHelper.LimitString(message.ErrorMessage, LIMIT); } }
// The thread that currently owns the lock on the specified object invokes this method to signal // all threads waiting to acquire the lock on the object. After the signal is sent, the waiting // threads are moved to the ready queue. When the thread that invoked PulseAll releases the lock, // the next thread in the ready queue acquires the lock. #endregion public static void PulseAll(object @lock) { if (@lock == null) { throw new ArgumentNullException(); } Helper.SimpleWrap <bool>( delegate(ClrSyncManager manager) { manager.SetMethodInfo("Monitor.PulseAll"); manager.SyncVarAccess(@lock, MSyncVarOp.LOCK_RELEASE); MonitorHelper.RemoveAllTasksFromWaitQueue(@lock); manager.CommitSyncVarAccess(); return(false); }, delegate() { Original::Monitor.PulseAll(@lock); return(false); }); }
private void OnMediaEnded(object sender, RoutedEventArgs args) { var mediaElement = (MediaElement)sender; var screen = (int)mediaElement.Tag; _logger.Debug($"Screen {screen}: Media ended {mediaElement.Source}"); if (DateTimeOffset.UtcNow >= _switchOffDate) { _logger.Debug("Switching off monitors"); foreach (var element in MediaElements) { element?.Stop(); } MonitorHelper.PowerOff(); } else { OnMediaEnded(mediaElement, screen); } }
/// <summary> /// Enumerates through each window. /// </summary> /// <param name="hWnd">The h WND.</param> /// <param name="lParam">The l parameter.</param> /// <returns></returns> private static bool EnumTheWindows(IntPtr hWnd, IntPtr lParam) { int size = WindowHelper.GetWindowTextLength(hWnd); // Get window area var rect = new RECT(); MonitorHelper.GetWindowRect(hWnd, ref rect); // Evaluate if (size++ <= 0 || !WindowHelper.IsWindowVisible(hWnd)) { return(true); } // Get window title var sb = new StringBuilder(size); WindowHelper.GetWindowText(hWnd, sb, size); // Get owning process id int processId = 0; WindowHelper.GetWindowThreadProcessId(hWnd, out processId); // Get current monitor var monitorHandle = MonitorHelper.MonitorFromRect(ref rect, MonitorPostion.MONITOR_DEFAULTTONEAREST); // Window rectange - valid var isWindowRectValid = MonitorHelper.IsWindowRectValid(rect); // Window state var isWindowResponding = !WindowHelper.IsHungAppWindow(hWnd); // Add to enumerated windows _enumeratedWindows.Add( new MainWindowProcess(processId, hWnd, sb.ToString(), monitorHandle, rect, isWindowRectValid, isWindowResponding)); return(true); }
public void Execute(IJobExecutionContext context) { MonitorHelper.TurnOff(); Thread.Sleep(TimeSpan.FromSeconds(2)); MonitorHelper.TurnOn(); }
private static void MoveToolTip(IInputElement target, ToolTip toolTip) { if (toolTip == null || target == null || toolTip.PlacementTarget == null) { return; } toolTip.Placement = PlacementMode.Relative; var hOffsetFromToolTip = GetAutoMoveHorizontalOffset(toolTip); var vOffsetFromToolTip = GetAutoMoveVerticalOffset(toolTip); var dpi = DpiHelper.GetDpi(toolTip); var hDPIOffset = DpiHelper.TransformToDeviceX(toolTip.PlacementTarget, hOffsetFromToolTip, dpi.DpiScaleX); var vDPIOffset = DpiHelper.TransformToDeviceY(toolTip.PlacementTarget, vOffsetFromToolTip, dpi.DpiScaleY); var position = Mouse.GetPosition(toolTip.PlacementTarget); var newHorizontalOffset = position.X + hDPIOffset; var newVerticalOffset = position.Y + vDPIOffset; var topLeftFromScreen = toolTip.PlacementTarget.PointToScreen(new Point(0, 0)); MONITORINFO monitorINFO = null; try { monitorINFO = MonitorHelper.GetMonitorInfoFromPoint(); } catch (UnauthorizedAccessException ex) { Debug.WriteLine("UnauthorizedAccessException occurred getting MONITORINFO: {0}", ex.Message); } if (monitorINFO != null) { Debug.WriteLine(">>rcWork >> w: {0} h: {1}", monitorINFO.rcWork.Width, monitorINFO.rcWork.Height); Debug.WriteLine(">>rcMonitor >> w: {0} h: {1}", monitorINFO.rcMonitor.Width, monitorINFO.rcMonitor.Height); var monitorWorkWidth = Math.Abs(monitorINFO.rcWork.Width); // (int)DpiHelper.TransformToDeviceX(toolTip.PlacementTarget, SystemParameters.PrimaryScreenWidth); var monitorWorkHeight = Math.Abs(monitorINFO.rcWork.Height); // (int)DpiHelper.TransformToDeviceY(toolTip.PlacementTarget, SystemParameters.PrimaryScreenHeight); if (topLeftFromScreen.X < 0) { topLeftFromScreen.X = -monitorINFO.rcWork.Left + topLeftFromScreen.X; } if (topLeftFromScreen.Y < 0) { topLeftFromScreen.Y = -monitorINFO.rcWork.Top + topLeftFromScreen.Y; } var locationX = (int)topLeftFromScreen.X % monitorWorkWidth; var locationY = (int)topLeftFromScreen.Y % monitorWorkHeight; var renderDPIWidth = DpiHelper.TransformToDeviceX(toolTip.RenderSize.Width, dpi.DpiScaleX); var rightX = locationX + newHorizontalOffset + renderDPIWidth; if (rightX > monitorWorkWidth) { newHorizontalOffset = position.X - toolTip.RenderSize.Width - 0.5 * hDPIOffset; } var renderDPIHeight = DpiHelper.TransformToDeviceY(toolTip.RenderSize.Height, dpi.DpiScaleY); var bottomY = locationY + newVerticalOffset + renderDPIHeight; if (bottomY > monitorWorkHeight) { newVerticalOffset = position.Y - toolTip.RenderSize.Height - 0.5 * vDPIOffset; } Debug.WriteLine(">>tooltip >> bottomY: {0:F} rightX: {1:F}", bottomY, rightX); toolTip.HorizontalOffset = newHorizontalOffset; toolTip.VerticalOffset = newVerticalOffset; Debug.WriteLine(">>offset >> ho: {0:F} vo: {1:F}", toolTip.HorizontalOffset, toolTip.VerticalOffset); } }
private void btnGammaStandard_Click(object sender, EventArgs e) { MonitorHelper.setGamma(120); }
public Ambilght(INanoleafClient nanoleafClient, Device device) { _nanoleafClient = nanoleafClient; _controlBrightness = device.ScreenMirrorControlBrightness; _screenBounds = MonitorHelper.GetScreenBounds(device.ScreenMirrorMonitorIndex); }