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);
}
